@skillsmith/cli 0.8.7 → 0.8.8

package/dist/cli.js

@@ -1767,7 +1767,7 @@ async function removeLinks(skillId) {
 }
 
 // ../core/dist/src/install/agent-pack-installer.js
-import { existsSync as existsSync9 } from "node:fs";
+import { existsSync as existsSync10 } from "node:fs";
 import { homedir as homedir6 } from "node:os";
 import { join as join16 } from "node:path";
 
@@ -2551,7 +2551,7 @@ var PAYWALL_TRIGGERS = [
   {
     id: "T2",
     title: "T2 - quota forecast (to Individual)",
-    body: `When usage is on track to exhaust the free 1,000-call monthly quota, you may note the forecast ("at this pace you reach the cap in about K days") and mention Individual's 10,000 calls. Use this sparingly; a quota nag reads as a tax.`
+    body: `When usage is on track to exhaust the free 100-call monthly quota, you may note the forecast ("at this pace you reach the cap in about K days") and mention Individual's 1,000 calls. Use this sparingly; a quota nag reads as a tax.`
   },
   {
     id: "T4",
@@ -3382,9 +3382,12 @@ function mergeJsonArrayEntry(opts) {
   let missingDefaults = false;
   if (ensureTopLevelDefaults) {
     for (const [key, value] of Object.entries(ensureTopLevelDefaults)) {
-      if (doc[key] === void 0) {
+      const existingValue = doc[key];
+      if (existingValue === void 0) {
         doc[key] = value;
         missingDefaults = true;
+      } else if (!deepEqualJson(existingValue, value)) {
+        return { status: "conflict", path: path27, backupPath: null };
       }
     }
   }
@@ -3695,6 +3698,7 @@ function installMcpConfig(harness, ctx, report) {
 }
 
 // ../core/dist/src/install/agent-pack-installer.cursor-hooks.js
+import { existsSync as existsSync9, readFileSync as readFileSync8, writeFileSync as writeFileSync9 } from "node:fs";
 import { join as join15 } from "node:path";
 function mergeSucceeded2(status) {
   return status === "created" || status === "updated" || status === "unchanged";
@@ -3753,16 +3757,81 @@ function installCursorHooks(startArtifact, endArtifact, ctx, report) {
     ensureTopLevelDefaults: CURSOR_HOOKS_JSON_DEFAULTS
   });
   report.hookConfig.push(startWire, endWire);
-  if (mergeSucceeded2(startWire.status) || mergeSucceeded2(endWire.status)) {
+  const wireConflict = startWire.status === "conflict" || endWire.status === "conflict";
+  const legacyCleanup = wireConflict ? null : stripStaleLegacyHookKeys(configPath2, startPath, endPath, ctx);
+  if (legacyCleanup)
+    report.hookConfig.push(legacyCleanup);
+  if (mergeSucceeded2(startWire.status) || mergeSucceeded2(endWire.status) || legacyCleanup !== null && mergeSucceeded2(legacyCleanup.status)) {
     ctx.entries.push({
       path: configPath2,
       kind: "hook-config",
       harness: "cursor",
-      backupPath: startWire.backupPath ?? endWire.backupPath,
+      backupPath: startWire.backupPath ?? endWire.backupPath ?? legacyCleanup?.backupPath ?? null,
       executable: false
     });
   }
 }
+function stripStaleLegacyHookKeys(configPath2, startPath, endPath, ctx) {
+  const unchanged = () => ({ status: "unchanged", path: configPath2, backupPath: null });
+  if (!existsSync9(configPath2))
+    return unchanged();
+  let doc;
+  try {
+    const parsed = JSON.parse(readFileSync8(configPath2, "utf-8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return {
+        status: "error",
+        path: configPath2,
+        backupPath: null,
+        errorMessage: "not a JSON object"
+      };
+    }
+    doc = parsed;
+  } catch (e) {
+    return {
+      status: "error",
+      path: configPath2,
+      backupPath: null,
+      errorMessage: e.message
+    };
+  }
+  const hooks = doc.hooks;
+  if (!hooks || typeof hooks !== "object" || Array.isArray(hooks))
+    return unchanged();
+  const hooksObj = hooks;
+  const claudeTarget = AGENT_HOOK_TARGETS["claude-code"];
+  const legacyStartKey = claudeTarget.sessionStartKeyPath.at(-1);
+  const legacyEndKey = claudeTarget.sessionEndKeyPath.at(-1);
+  let changed = false;
+  for (const [legacyKey, ownPath] of [
+    [legacyStartKey, startPath],
+    [legacyEndKey, endPath]
+  ]) {
+    if (legacyKey === void 0)
+      continue;
+    const legacyValue = hooksObj[legacyKey];
+    if (legacyValue === void 0)
+      continue;
+    if (!Array.isArray(legacyValue))
+      continue;
+    const remaining = legacyValue.filter((item) => hookEntryCommand(item) !== ownPath);
+    const needsCleanup = legacyValue.length === 0 || remaining.length !== legacyValue.length;
+    if (!needsCleanup)
+      continue;
+    changed = true;
+    if (remaining.length === 0) {
+      delete hooksObj[legacyKey];
+    } else {
+      hooksObj[legacyKey] = remaining;
+    }
+  }
+  if (!changed)
+    return unchanged();
+  const backupPath = shouldBackup(configPath2, ctx.backedUpPaths) ? writeBackup5(configPath2, ctx.backupDir) : null;
+  markBackedUp(configPath2, ctx.backedUpPaths);
+  writeFileSync9(configPath2, JSON.stringify(doc, null, 2) + "\n", { mode: 384 });
+  return { status: "updated", path: configPath2, backupPath };
+}
 function cursorHookEntry(scriptPath) {
   return { command: scriptPath };
 }
@@ -3787,10 +3856,10 @@ var HARNESS_SUPPORT_TIER = {
 // ../core/dist/src/install/agent-pack-installer.js
 var OPTIONAL_SKILL_PACK_HARNESSES = ["windsurf", "opencode", "hermes"];
 function isPresent(nativePath, homeDir) {
-  return existsSync9(relocateUnderHome(nativePath, homeDir));
+  return existsSync10(relocateUnderHome(nativePath, homeDir));
 }
 function isCodexPresent(homeDir) {
-  return existsSync9(relocateUnderHome(join16(homedir6(), ".codex"), homeDir));
+  return existsSync10(relocateUnderHome(join16(homedir6(), ".codex"), homeDir));
 }
 function writeSkillPackFor(clientNativePath, content, ctx, harness) {
   const path27 = join16(relocateUnderHome(clientNativePath, ctx.homeDir), AGENT_PACK_SKILL_NAME, "SKILL.md");
@@ -3824,7 +3893,7 @@ function newReport(harness) {
 function carryForwardPriorBackups(entries) {
   const priorBackupByPath = /* @__PURE__ */ new Map();
   for (const prior of loadAgentManifest().entries) {
-    if (prior.backupPath && existsSync9(prior.backupPath)) {
+    if (prior.backupPath && existsSync10(prior.backupPath)) {
       priorBackupByPath.set(prior.path, prior.backupPath);
     }
   }
@@ -3921,7 +3990,7 @@ function installAgentPack(opts = {}) {
 
 // ../core/dist/src/install/agent-pack-uninstaller.js
 import { dirname as dirname9 } from "node:path";
-import { existsSync as existsSync10, readFileSync as readFileSync8, rmdirSync, unlinkSync as unlinkSync2, writeFileSync as writeFileSync9 } from "node:fs";
+import { existsSync as existsSync11, readFileSync as readFileSync9, rmdirSync, unlinkSync as unlinkSync2, writeFileSync as writeFileSync10 } from "node:fs";
 
 // ../core/dist/src/install/agent-manifest-path-guard.js
 import { homedir as homedir7 } from "node:os";
@@ -3989,14 +4058,14 @@ function uninstallAgentPack(_opts = {}) {
       rejected.push(entry.path);
       continue;
     }
-    if (!existsSync10(entry.path)) {
+    if (!existsSync11(entry.path)) {
       alreadyGone.push(entry.path);
       continue;
     }
     touchedDirs.add(dirname9(entry.path));
-    if (entry.backupPath && existsSync10(entry.backupPath)) {
-      const content = readFileSync8(entry.backupPath, "utf-8");
-      writeFileSync9(entry.path, content, "utf-8");
+    if (entry.backupPath && existsSync11(entry.backupPath)) {
+      const content = readFileSync9(entry.backupPath, "utf-8");
+      writeFileSync10(entry.path, content, "utf-8");
       restored.push(entry.path);
     } else {
       unlinkSync2(entry.path);
@@ -20476,6 +20545,36 @@ function assertEvidenceCoverage() {
 }
 assertEvidenceCoverage();
 
+// ../core/dist/src/security/scanner/patterns.exec.js
+var CODE_EXECUTION_PATTERNS = [
+  // curl|wget <target> | [sudo] <interpreter>  (fetch piped to a shell or scripting interpreter)
+  /(?:curl|wget)\b[^\n|]{0,150}?(?:https?:\/\/|\d{1,3}(?:\.\d{1,3}){3}|[\w-]{2,63}\.[a-z]{2,24})[^\n|]{0,150}?\|\s*(?:sudo\s+(?:-[A-Za-z]+\s+)?)?(?:(?:ba|z|da)?sh|python[23]?|node|ruby|perl|php|fish|bun|deno)\b/i,
+  // process substitution: bash/sh/zsh/source/. <(curl|wget <target> ...)
+  /(?:^|[\s;&])(?:source|\.|ba?sh|zsh|exec)\s+<\(\s*(?:curl|wget)\b[^\n)]{0,150}?(?:https?:\/\/|\d{1,3}(?:\.\d{1,3}){3}|[\w-]{2,63}\.[a-z]{2,24})/i,
+  // command substitution into eval or `sh -c`: eval "$(curl <target>...)", bash -c "`wget <target>...`"
+  /(?:\beval\b|(?:ba|z)?sh\s+-c)\s+["']?[$`]\(?\s*(?:curl|wget)\b[^\n)]{0,150}?(?:https?:\/\/|\d{1,3}(?:\.\d{1,3}){3}|[\w-]{2,63}\.[a-z]{2,24})/i,
+  // PowerShell download-and-execute: iex(irm ...), Invoke-Expression(... DownloadString/Invoke-WebRequest)
+  /\b(?:iex|invoke-expression)\b[^\n]{0,100}?(?:\birm\b|\biwr\b|invoke-webrequest|invoke-restmethod|downloadstring|net\.webclient)/i,
+  // PowerShell encoded command (base64 payload handed to the interpreter)
+  /\bpowershell\b[^\n]{0,60}?\s-e(?:nc|ncodedcommand)?\b\s*[A-Za-z0-9+/=]{16,}/i,
+  // decode-then-exec: ... base64 -d ... | <interpreter> (SMI-5359 retro NIT: da sink, matches the curl pattern)
+  /\bbase64\s+(?:-d|--decode|-D)\b[^\n|]{0,60}?\|\s*(?:(?:ba|z|da)?sh|python[23]?|node|ruby|perl|php|fish|bun|deno)\b/i,
+  // SMI-5424 FN-1: chained / redirect download-then-execute (curl URL -o /tmp/x && bash /tmp/x)
+  /(?:curl|wget)\b[^\n]{0,150}?(?:https?:\/\/|\d{1,3}(?:\.\d{1,3}){3}|[\w-]{2,63}\.[a-z]{2,24})[^\n]{0,150}?(?:&&|;)\s*(?:sudo\s+(?:-[A-Za-z]+\s+)?)?(?:(?:ba|z|da)?sh|python[23]?|node|ruby|perl|php|fish|bun|deno)\b/i,
+  // SMI-5424 FN-2: npx executing a REMOTE source (URL or github:), never a local package (npx tsc is clean)
+  /\bnpx\s+(?:--yes\s+|-y\s+)?(?:https?:\/\/\S+|github:\S+)/i,
+  // SMI-5424 FN-4: node/python/deno/bun inline-eval (-e/-c) with a dangerous payload
+  /\b(?:node|python[23]?|deno|bun)\s+(?:-e|-c|--eval|--exec)\s+['"][^'"]{0,200}?(?:require\(|child_process|fetch\(|\bexec\b|eval\(|base64|urllib|os\.system|subprocess)/i
+];
+var IMPERATIVE_FETCH_EXEC_PROSE = [
+  // P1: <fetch verb> … <exec noun> … <remote target> … <execution imperative>
+  //     "Download the installer from thisurl.com and run it"
+  /\b(?:download|fetch|grab|get)\b[\s\S]{0,40}?\b(?:file|binary|executable|script|installer|setup)\b[\s\S]{0,60}?(?:https?:\/\/[^\s"'<>)\]]{1,200}|\b(?:from|at|on|via)\s+(?:the\s+)?[\w-]{2,63}(?:\.[\w-]{2,63}){0,3}\.(?!(?:sh|bash|zsh|exe|py|js|mjs|cjs|ts|md|txt|zip|tar|gz|tgz|json|ya?ml|toml|bin|dmg|pkg|msi|deb|rpm|jar|php|rb|pl|ps1|bat|cmd|app)\b)[a-z]{2,24}\b)[\s\S]{0,120}?\b(?:run|execute|open|install)\s+(?:it|this|that|them|(?:the|this|that|your)\s+(?:file|binary|executable|script|installer|setup))\b/i,
+  // P2: <execution imperative + exec noun> … <fetch verb> … <remote target>
+  //     "Run the installer you downloaded from thisurl.com"
+  /\b(?:run|execute|open|install)\s+(?:the|this|that|your)\s+(?:file|binary|executable|script|installer|setup)\b[\s\S]{0,80}?\b(?:download|fetch|grab|get)(?:ed|s|ing)?\b[\s\S]{0,60}?(?:https?:\/\/[^\s"'<>)\]]{1,200}|\b(?:from|at|on|via)\s+(?:the\s+)?[\w-]{2,63}(?:\.[\w-]{2,63}){0,3}\.(?!(?:sh|bash|zsh|exe|py|js|mjs|cjs|ts|md|txt|zip|tar|gz|tgz|json|ya?ml|toml|bin|dmg|pkg|msi|deb|rpm|jar|php|rb|pl|ps1|bat|cmd|app)\b)[a-z]{2,24}\b)/i
+];
+
 // ../core/dist/src/security/scanner/patterns.js
 var DEFAULT_ALLOWED_DOMAINS = [
   "github.com",
@@ -20491,6 +20590,24 @@ var DEFAULT_ALLOWED_DOMAINS = [
   "nodejs.org",
   "typescriptlang.org"
 ];
+var ANON_PASTE_HOSTS = [
+  "glot.io",
+  "pastebin.com",
+  "paste.ee",
+  "hastebin.com",
+  "ix.io",
+  "0x0.st",
+  "dpaste.org",
+  "dpaste.com",
+  "ghostbin.com",
+  "paste.rs",
+  "controlc.com",
+  "rentry.co",
+  "paste.gg",
+  "justpaste.it"
+];
+var TRANSIENT_TRANSFER_HOSTS = ["transfer.sh", "file.io", "tmpfiles.org", "temp.sh"];
+var URL_SHORTENER_DOMAINS = ["bit.ly", "tinyurl.com", "t.co", "is.gd"];
 var ENV_PATH_PATTERN = /\.env(?![A-Za-z])(?!\.(?:example|sample|template|schema|dist))/i;
 var API_KEY_KEYWORD = /api[_-]?key/i;
 var AUTH_TOKEN_KEYWORD = /auth[_-]?token/i;
@@ -20521,7 +20638,7 @@ var VALUE_GATED_KEYWORD_PATTERNS = /* @__PURE__ */ new Set([
   API_KEY_KEYWORD,
   AUTH_TOKEN_KEYWORD
 ]);
-var SCANNER_RULESET_VERSION = "2026-07-29.1";
+var SCANNER_RULESET_VERSION = "2026-08-15.1";
 var SUSPICIOUS_PATTERNS = [
   /eval\s*\(/i,
   /exec\s*\(/i,
@@ -20537,26 +20654,6 @@ var SUSPICIOUS_PATTERNS = [
   // Curl pipe to shell
   /wget\s+.*\|\s*(bash|sh)/i
 ];
-var CODE_EXECUTION_PATTERNS = [
-  // curl|wget <target> | [sudo] <interpreter>  (fetch piped to a shell or scripting interpreter)
-  /(?:curl|wget)\b[^\n|]{0,150}?(?:https?:\/\/|\d{1,3}(?:\.\d{1,3}){3}|[\w-]{2,63}\.[a-z]{2,24})[^\n|]{0,150}?\|\s*(?:sudo\s+(?:-[A-Za-z]+\s+)?)?(?:(?:ba|z|da)?sh|python[23]?|node|ruby|perl|php|fish|bun|deno)\b/i,
-  // process substitution: bash/sh/zsh/source/. <(curl|wget <target> ...)
-  /(?:^|[\s;&])(?:source|\.|ba?sh|zsh|exec)\s+<\(\s*(?:curl|wget)\b[^\n)]{0,150}?(?:https?:\/\/|\d{1,3}(?:\.\d{1,3}){3}|[\w-]{2,63}\.[a-z]{2,24})/i,
-  // command substitution into eval or `sh -c`: eval "$(curl <target>...)", bash -c "`wget <target>...`"
-  /(?:\beval\b|(?:ba|z)?sh\s+-c)\s+["']?[$`]\(?\s*(?:curl|wget)\b[^\n)]{0,150}?(?:https?:\/\/|\d{1,3}(?:\.\d{1,3}){3}|[\w-]{2,63}\.[a-z]{2,24})/i,
-  // PowerShell download-and-execute: iex(irm ...), Invoke-Expression(... DownloadString/Invoke-WebRequest)
-  /\b(?:iex|invoke-expression)\b[^\n]{0,100}?(?:\birm\b|\biwr\b|invoke-webrequest|invoke-restmethod|downloadstring|net\.webclient)/i,
-  // PowerShell encoded command (base64 payload handed to the interpreter)
-  /\bpowershell\b[^\n]{0,60}?\s-e(?:nc|ncodedcommand)?\b\s*[A-Za-z0-9+/=]{16,}/i,
-  // decode-then-exec: ... base64 -d ... | <interpreter> (SMI-5359 retro NIT: da sink, matches the curl pattern)
-  /\bbase64\s+(?:-d|--decode|-D)\b[^\n|]{0,60}?\|\s*(?:(?:ba|z|da)?sh|python[23]?|node|ruby|perl|php|fish|bun|deno)\b/i,
-  // SMI-5424 FN-1: chained / redirect download-then-execute (curl URL -o /tmp/x && bash /tmp/x)
-  /(?:curl|wget)\b[^\n]{0,150}?(?:https?:\/\/|\d{1,3}(?:\.\d{1,3}){3}|[\w-]{2,63}\.[a-z]{2,24})[^\n]{0,150}?(?:&&|;)\s*(?:sudo\s+(?:-[A-Za-z]+\s+)?)?(?:(?:ba|z|da)?sh|python[23]?|node|ruby|perl|php|fish|bun|deno)\b/i,
-  // SMI-5424 FN-2: npx executing a REMOTE source (URL or github:), never a local package (npx tsc is clean)
-  /\bnpx\s+(?:--yes\s+|-y\s+)?(?:https?:\/\/\S+|github:\S+)/i,
-  // SMI-5424 FN-4: node/python/deno/bun inline-eval (-e/-c) with a dangerous payload
-  /\b(?:node|python[23]?|deno|bun)\s+(?:-e|-c|--eval|--exec)\s+['"][^'"]{0,200}?(?:require\(|child_process|fetch\(|\bexec\b|eval\(|base64|urllib|os\.system|subprocess)/i
-];
 var SOCIAL_ENGINEERING_PATTERNS = [
   /pretend\s+(to\s+be|you\s+are|that\s+you)/i,
   /roleplay\s+as/i,
@@ -20823,7 +20920,47 @@ var CATEGORY_WEIGHTS = {
   // ~1) to the total; a saturated breakdown (capped at 100) contributes 4 —
   // comfortably under the riskThreshold: 40 quarantine cutoff on its own. See the
   // stacked-risk test in SecurityScanner.scoring.test.ts.
-  typosquat: 1.2
+  typosquat: 1.2,
+  // SMI-6033 Wave 2 (Gap 5/Gap 3): top-tier weight matching code_execution/
+  // obfuscated_directive — the SAME single weight is used for both the
+  // critical (standalone-quarantining) and medium (advisory, co-signal-
+  // eligible) forms of each type; severity alone (SEVERITY_WEIGHTS 50 vs 15)
+  // does the two-tier split, exactly as scanChmodFetchCompound's own
+  // privilege_escalation compound signal already does with ONE weight
+  // (1.9/0.11) across its high/low severities. Paired with the 0.40
+  // coefficient in calculateRiskScore: a single CRITICAL finding reaches
+  // exactly the 40 quarantine threshold on its own (50 * 2.0 * 1.0 = 100 ->
+  // capped 100 -> * 0.40 = 40); a single MEDIUM finding contributes 12
+  // (15 * 2.0 * 1.0 = 30 -> * 0.40 = 12) — well under threshold alone.
+  gatekeeper_bypass: 2,
+  archive_evasion: 2,
+  // SMI-6033 Wave 2 (Gap 4): same top-tier weight as gatekeeper_bypass/
+  // archive_evasion, for the same reason — a paste-host URL that is the
+  // TARGET of a fetch command reaches exactly the 40 quarantine threshold
+  // standalone (50 * 2.0 * 1.0 = 100 -> capped 100 -> * 0.40 = 40), while a
+  // paste-host URL that is merely linked never reaches this detector at all
+  // (see SecurityScanner.paste-host.ts) and stays covered by the existing
+  // url:medium finding instead.
+  paste_host_fetch: 2,
+  // SMI-6033 Wave 2 (Gap 2): the sensitive_path/typosquat tier (1.2/0.04 —
+  // NOT the 2.0/0.40 tier every other Wave 2 detector above uses). This
+  // detector's wrapper finding is deliberately advisory-only: the escalation
+  // Gap 2 achieves comes for free from the decoded content's OWN findings
+  // (e.g. a decoded `curl|bash` natively trips code_execution at ITS OWN
+  // top-tier weight), not from encoded_payload itself. A single medium,
+  // high-confidence finding scores 15 * 1.2 * 1.0 = 18 -> * 0.04 = 0.72
+  // (rounds to ~1); a saturated breakdown (capped at 100) contributes 4 —
+  // comfortably under the riskThreshold: 40 quarantine cutoff on its own.
+  encoded_payload: 1.2,
+  // SMI-6033 Wave 4 (Gap 6): same advisory tier as typosquat/encoded_payload/
+  // sensitive_path (1.2/0.04) — NOT the 2.0/0.40 top tier gatekeeper_bypass/
+  // archive_evasion/paste_host_fetch use, since this finding type must never
+  // be standalone-critical (plan §9: "N/A — never standalone... Approximate
+  // NL heuristic by construction; co-signal required"). A single medium,
+  // high-confidence finding scores 15 * 1.2 * 1.0 = 18 -> * 0.04 = 0.72
+  // (rounds to ~1); a saturated breakdown (capped at 100) contributes 4 —
+  // comfortably under the riskThreshold: 40 quarantine cutoff on its own.
+  decoy_misdirection: 1.2
 };
 
 // ../core/dist/src/security/scanner/regex-utils.js
@@ -21076,7 +21213,7 @@ function assertScopeCoverage() {
 assertScopeCoverage();
 
 // ../core/dist/src/security/scanner/SecurityScanner.helpers.js
-function analyzeMarkdownContext(content) {
+function analyzeMarkdownContext(content, isMarkdown = true) {
   const lines = content.split("\n");
   const contexts = [];
   let inFencedCodeBlock = false;
@@ -21104,7 +21241,7 @@ function analyzeMarkdownContext(content) {
       inFencedCodeBlock = !inFencedCodeBlock;
     }
     const inTable = !lineInFrontmatter && trimmedLine.startsWith("|");
-    const isIndentedCode = !lineInFrontmatter && /^( {4,}|\t)/.test(line) && !inFencedCodeBlock && !trimmedLine.startsWith("-") && !trimmedLine.startsWith("*");
+    const isIndentedCode = isMarkdown && !lineInFrontmatter && /^( {4,}|\t)/.test(line) && !inFencedCodeBlock && !trimmedLine.startsWith("-") && !trimmedLine.startsWith("*");
     const isInlineCode = !lineInFrontmatter && /`[^`]+`/.test(line) && !inFencedCodeBlock;
     contexts.push({
       lineNumber: i + 1,
@@ -21216,95 +21353,6 @@ function scanPatternsWithMultilineSupport(content, config2, lineContexts, maxLen
   }
   return findings;
 }
-function calculateRiskScore(findings) {
-  const breakdown = {
-    jailbreak: 0,
-    socialEngineering: 0,
-    promptLeaking: 0,
-    dataExfiltration: 0,
-    privilegeEscalation: 0,
-    suspiciousCode: 0,
-    sensitivePaths: 0,
-    externalUrls: 0,
-    aiDefence: 0,
-    ssrf: 0,
-    pii: 0,
-    codeExecution: 0,
-    obfuscatedDirective: 0,
-    typosquat: 0
-  };
-  const confidenceWeights = {
-    high: 1,
-    medium: 0.7,
-    low: 0.3
-  };
-  for (const finding of findings) {
-    const severityWeight = SEVERITY_WEIGHTS[finding.severity];
-    const categoryWeight = CATEGORY_WEIGHTS[finding.type] ?? 1;
-    const confidenceWeight = confidenceWeights[finding.confidence ?? "high"];
-    const score = severityWeight * categoryWeight * confidenceWeight;
-    switch (finding.type) {
-      case "jailbreak":
-        breakdown.jailbreak += score;
-        break;
-      case "social_engineering":
-        breakdown.socialEngineering += score;
-        break;
-      case "prompt_leaking":
-        breakdown.promptLeaking += score;
-        break;
-      case "data_exfiltration":
-        breakdown.dataExfiltration += score;
-        break;
-      case "privilege_escalation":
-        breakdown.privilegeEscalation += score;
-        break;
-      case "suspicious_pattern":
-        breakdown.suspiciousCode += score;
-        break;
-      case "sensitive_path":
-        breakdown.sensitivePaths += score;
-        break;
-      case "url":
-        breakdown.externalUrls += score;
-        break;
-      case "ai_defence":
-        breakdown.aiDefence += score;
-        break;
-      case "ssrf":
-        breakdown.ssrf += score;
-        break;
-      case "pii":
-        breakdown.pii += score;
-        break;
-      case "code_execution":
-        breakdown.codeExecution += score;
-        break;
-      case "obfuscated_directive":
-        breakdown.obfuscatedDirective += score;
-        break;
-      case "typosquat":
-        breakdown.typosquat += score;
-        break;
-    }
-  }
-  breakdown.jailbreak = Math.min(100, breakdown.jailbreak);
-  breakdown.socialEngineering = Math.min(100, breakdown.socialEngineering);
-  breakdown.promptLeaking = Math.min(100, breakdown.promptLeaking);
-  breakdown.dataExfiltration = Math.min(100, breakdown.dataExfiltration);
-  breakdown.privilegeEscalation = Math.min(100, breakdown.privilegeEscalation);
-  breakdown.suspiciousCode = Math.min(100, breakdown.suspiciousCode);
-  breakdown.sensitivePaths = Math.min(100, breakdown.sensitivePaths);
-  breakdown.externalUrls = Math.min(100, breakdown.externalUrls);
-  breakdown.aiDefence = Math.min(100, breakdown.aiDefence);
-  breakdown.ssrf = Math.min(100, breakdown.ssrf);
-  breakdown.pii = Math.min(100, breakdown.pii);
-  breakdown.codeExecution = Math.min(100, breakdown.codeExecution);
-  breakdown.obfuscatedDirective = Math.min(100, breakdown.obfuscatedDirective);
-  breakdown.typosquat = Math.min(100, breakdown.typosquat);
-  const total = Math.min(100, Math.round(breakdown.jailbreak * 0.2 + breakdown.socialEngineering * 0.11 + breakdown.promptLeaking * 0.11 + breakdown.dataExfiltration * 0.08 + breakdown.privilegeEscalation * 0.11 + breakdown.suspiciousCode * 0.07 + breakdown.sensitivePaths * 0.04 + breakdown.externalUrls * 0.04 + breakdown.aiDefence * 0.12 + breakdown.ssrf * 0.04 + breakdown.pii * 0.08 + breakdown.codeExecution * 0.4 + breakdown.obfuscatedDirective * 0.4 + breakdown.typosquat * 0.04));
-  return { total, breakdown };
-}
 
 // ../core/dist/src/security/scanner/confusables.js
 var CONFUSABLES = {
@@ -21383,25 +21431,33 @@ var OBFUSCATION_DIRECTIVE_PATTERN = /(?:ignore|disregard|forget)\s+(?:all\s+|the
 function scanCodeExecution(content, lineContexts) {
   const lines = content.split("\n");
   const contexts = lineContexts ?? analyzeMarkdownContext(content);
+  const emit = (i, line, matched, prefix) => {
+    const ctx = contexts[i];
+    const inDocContext = ctx ? isDocumentationContext(ctx) : false;
+    return [
+      {
+        type: "code_execution",
+        severity: "medium",
+        message: `${prefix}: "${matched.slice(0, 60)}${matched.length > 60 ? "..." : ""}"`,
+        location: line.trim().slice(0, 100),
+        lineNumber: i + 1,
+        category: "code_execution",
+        inDocumentationContext: inDocContext,
+        confidence: "high"
+      }
+    ];
+  };
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i];
     for (const pattern of CODE_EXECUTION_PATTERNS) {
+      const match = safeRegexTest(pattern, line);
+      if (match)
+        return emit(i, line, match[0], "Remote fetch piped to an interpreter");
+    }
+    for (const pattern of IMPERATIVE_FETCH_EXEC_PROSE) {
       const match = safeRegexTest(pattern, line);
       if (match) {
-        const ctx = contexts[i];
-        const inDocContext = ctx ? isDocumentationContext(ctx) : false;
-        return [
-          {
-            type: "code_execution",
-            severity: "medium",
-            message: `Remote fetch piped to an interpreter: "${match[0].slice(0, 60)}${match[0].length > 60 ? "..." : ""}"`,
-            location: line.trim().slice(0, 100),
-            lineNumber: i + 1,
-            category: "code_execution",
-            inDocumentationContext: inDocContext,
-            confidence: "high"
-          }
-        ];
+        return emit(i, line, match[0], "Natural-language instruction to fetch a remote file and execute it");
       }
     }
   }
@@ -21446,29 +21502,71 @@ function scanObfuscatedDirective(content) {
   }
   return [];
 }
-var CODE_EXECUTION_CO_OCCURRENCE = /* @__PURE__ */ new Set([
-  "data_exfiltration",
-  "privilege_escalation",
-  "sensitive_path",
-  "obfuscated_directive"
-]);
+var CO_SIGNAL_MIN_SEVERITY = {
+  // Existing four — behavior byte-identical to today, min 'high'.
+  data_exfiltration: "high",
+  privilege_escalation: "high",
+  sensitive_path: "high",
+  obfuscated_directive: "high",
+  // New ClawHavoc advisory-tier categories — eligible at 'medium'.
+  decoy_misdirection: "medium",
+  archive_evasion: "medium",
+  paste_host_fetch: "medium",
+  gatekeeper_bypass: "medium"
+  // its correlated/critical form already quarantines on its own
+};
+var SEVERITY_RANK = { low: 0, medium: 1, high: 2, critical: 3 };
 var MAX_CODE_EXECUTION_CO_SIGNAL_LINE_DISTANCE = 40;
 function isWithinCoSignalWindow(codeExecLine, coSignalLine) {
   if (typeof codeExecLine !== "number" || typeof coSignalLine !== "number")
     return true;
   return Math.abs(codeExecLine - coSignalLine) <= MAX_CODE_EXECUTION_CO_SIGNAL_LINE_DISTANCE;
 }
+var CO_SIGNAL_MEDIUM_CONFIDENCE_EXCEPTION = /* @__PURE__ */ new Set([
+  "paste_host_fetch"
+]);
 function escalateCodeExecution(findings) {
   const codeExec = findings.find((f) => f.type === "code_execution");
   if (!codeExec)
     return;
-  const hasDangerousCoSignal = findings.some((f) => f !== codeExec && CODE_EXECUTION_CO_OCCURRENCE.has(f.type) && f.inDocumentationContext !== true && (f.severity === "high" || f.severity === "critical") && isWithinCoSignalWindow(codeExec.lineNumber, f.lineNumber));
+  if (codeExec.inDocumentationContext === true)
+    return;
+  const eligible = findings.filter((f) => f !== codeExec && CO_SIGNAL_MIN_SEVERITY[f.type] !== void 0 && f.inDocumentationContext !== true && isWithinCoSignalWindow(codeExec.lineNumber, f.lineNumber));
+  const hasDangerousCoSignal = eligible.some((f) => CO_SIGNAL_MIN_SEVERITY[f.type] === "high" && (f.severity === "high" || f.severity === "critical"));
   if (hasDangerousCoSignal) {
     codeExec.severity = "critical";
     codeExec.message = `Remote fetch piped to an interpreter, co-occurring with exfiltration/privilege/credential signals \u2014 likely supply-chain execution. ${codeExec.message}`;
+    return;
+  }
+  const advisoryTypes = new Set(eligible.filter((f) => {
+    const min = CO_SIGNAL_MIN_SEVERITY[f.type];
+    const confidenceOk = CO_SIGNAL_MEDIUM_CONFIDENCE_EXCEPTION.has(f.type) ? f.confidence !== "low" : f.confidence === "high";
+    return min === "medium" && SEVERITY_RANK[f.severity] >= SEVERITY_RANK[min] && confidenceOk;
+  }).map((f) => f.type));
+  if (advisoryTypes.size >= 2) {
+    codeExec.severity = "critical";
+    codeExec.message = `Remote fetch/execute instruction corroborated by two independent advisory-tier signals (${[
+      ...advisoryTypes
+    ].sort().join(", ")}) \u2014 likely supply-chain execution. ${codeExec.message}`;
   }
 }
 
+// ../core/dist/src/security/scanner/typosquat.js
+var BRAND_ALIASES = {
+  anthropic: "anthropics",
+  claude: "anthropics",
+  gemini: "google-gemini",
+  copilot: "microsoft",
+  vercel: "vercel-labs",
+  salesforce: "SalesforceCommerceCloud"
+};
+var AUTHORITY_CLAIMING_AFFIXES = /* @__PURE__ */ new Set([
+  "official",
+  "verified",
+  "authentic",
+  "genuine"
+]);
+
 // ../core/dist/src/security/scanner/SecurityScanner.formatters.js
 function toMinimalRefs(report) {
   return report.findings.map((finding) => {
@@ -21570,6 +21668,137 @@ function toSummary(report) {
   };
 }
 
+// ../core/dist/src/security/scanner/SecurityScanner.urls.js
+function extractUrls(content) {
+  const urlPattern = /https?:\/\/[^\s<>"')\]]+/gi;
+  const lines = content.split("\n");
+  const results = [];
+  lines.forEach((line, index) => {
+    let match;
+    while ((match = urlPattern.exec(line)) !== null) {
+      results.push({ url: match[0], line: index + 1 });
+    }
+  });
+  return results;
+}
+
+// ../core/dist/src/security/scanner/SecurityScanner.risk-score.js
+function calculateRiskScore(findings) {
+  const breakdown = {
+    jailbreak: 0,
+    socialEngineering: 0,
+    promptLeaking: 0,
+    dataExfiltration: 0,
+    privilegeEscalation: 0,
+    suspiciousCode: 0,
+    sensitivePaths: 0,
+    externalUrls: 0,
+    aiDefence: 0,
+    ssrf: 0,
+    pii: 0,
+    codeExecution: 0,
+    obfuscatedDirective: 0,
+    typosquat: 0,
+    gatekeeperBypass: 0,
+    archiveEvasion: 0,
+    pasteHostFetch: 0,
+    encodedPayload: 0,
+    decoyMisdirection: 0
+  };
+  const confidenceWeights = {
+    high: 1,
+    medium: 0.7,
+    low: 0.3
+  };
+  for (const finding of findings) {
+    const severityWeight = SEVERITY_WEIGHTS[finding.severity];
+    const categoryWeight = CATEGORY_WEIGHTS[finding.type] ?? 1;
+    const confidenceWeight = confidenceWeights[finding.confidence ?? "high"];
+    const score = severityWeight * categoryWeight * confidenceWeight;
+    switch (finding.type) {
+      case "jailbreak":
+        breakdown.jailbreak += score;
+        break;
+      case "social_engineering":
+        breakdown.socialEngineering += score;
+        break;
+      case "prompt_leaking":
+        breakdown.promptLeaking += score;
+        break;
+      case "data_exfiltration":
+        breakdown.dataExfiltration += score;
+        break;
+      case "privilege_escalation":
+        breakdown.privilegeEscalation += score;
+        break;
+      case "suspicious_pattern":
+        breakdown.suspiciousCode += score;
+        break;
+      case "sensitive_path":
+        breakdown.sensitivePaths += score;
+        break;
+      case "url":
+        breakdown.externalUrls += score;
+        break;
+      case "ai_defence":
+        breakdown.aiDefence += score;
+        break;
+      case "ssrf":
+        breakdown.ssrf += score;
+        break;
+      case "pii":
+        breakdown.pii += score;
+        break;
+      case "code_execution":
+        breakdown.codeExecution += score;
+        break;
+      case "obfuscated_directive":
+        breakdown.obfuscatedDirective += score;
+        break;
+      case "typosquat":
+        breakdown.typosquat += score;
+        break;
+      case "gatekeeper_bypass":
+        breakdown.gatekeeperBypass += score;
+        break;
+      case "archive_evasion":
+        breakdown.archiveEvasion += score;
+        break;
+      case "paste_host_fetch":
+        breakdown.pasteHostFetch += score;
+        break;
+      case "encoded_payload":
+        breakdown.encodedPayload += score;
+        break;
+      case "decoy_misdirection":
+        breakdown.decoyMisdirection += score;
+        break;
+    }
+  }
+  breakdown.jailbreak = Math.min(100, breakdown.jailbreak);
+  breakdown.socialEngineering = Math.min(100, breakdown.socialEngineering);
+  breakdown.promptLeaking = Math.min(100, breakdown.promptLeaking);
+  breakdown.dataExfiltration = Math.min(100, breakdown.dataExfiltration);
+  breakdown.privilegeEscalation = Math.min(100, breakdown.privilegeEscalation);
+  breakdown.suspiciousCode = Math.min(100, breakdown.suspiciousCode);
+  breakdown.sensitivePaths = Math.min(100, breakdown.sensitivePaths);
+  breakdown.externalUrls = Math.min(100, breakdown.externalUrls);
+  breakdown.aiDefence = Math.min(100, breakdown.aiDefence);
+  breakdown.ssrf = Math.min(100, breakdown.ssrf);
+  breakdown.pii = Math.min(100, breakdown.pii);
+  breakdown.codeExecution = Math.min(100, breakdown.codeExecution);
+  breakdown.obfuscatedDirective = Math.min(100, breakdown.obfuscatedDirective);
+  breakdown.typosquat = Math.min(100, breakdown.typosquat);
+  breakdown.gatekeeperBypass = Math.min(100, breakdown.gatekeeperBypass);
+  breakdown.archiveEvasion = Math.min(100, breakdown.archiveEvasion);
+  breakdown.pasteHostFetch = Math.min(100, breakdown.pasteHostFetch);
+  breakdown.encodedPayload = Math.min(100, breakdown.encodedPayload);
+  breakdown.decoyMisdirection = Math.min(100, breakdown.decoyMisdirection);
+  const total = Math.min(100, Math.round(breakdown.jailbreak * 0.2 + breakdown.socialEngineering * 0.11 + breakdown.promptLeaking * 0.11 + breakdown.dataExfiltration * 0.08 + breakdown.privilegeEscalation * 0.11 + breakdown.suspiciousCode * 0.07 + breakdown.sensitivePaths * 0.04 + breakdown.externalUrls * 0.04 + breakdown.aiDefence * 0.12 + breakdown.ssrf * 0.04 + breakdown.pii * 0.08 + breakdown.codeExecution * 0.4 + breakdown.obfuscatedDirective * 0.4 + breakdown.typosquat * 0.04 + breakdown.gatekeeperBypass * 0.4 + breakdown.archiveEvasion * 0.4 + breakdown.pasteHostFetch * 0.4 + breakdown.encodedPayload * 0.04 + // SMI-6033 Wave 4 (Gap 6): additive 0.04, same advisory tier as encodedPayload/typosquat.
+  breakdown.decoyMisdirection * 0.04));
+  return { total, breakdown };
+}
+
 // ../core/dist/src/security/scanner/SecurityScanner.ssrf.js
 function scanSsrfPatterns(content, lineContexts, maxLength) {
   const findings = [];
@@ -21718,14 +21947,40 @@ function scanPiiPatterns(content, lineContexts) {
   return findings;
 }
 
-// ../core/dist/src/security/scanner/SecurityScanner.compound.js
-var OWNER_PERM_CHMOD = /\bchmod\s+(?:-[A-Za-z]+\s+)?(?:[0-7]{3,4}|[ugoa]*(?:[+\-=][rwxXstugo]+(?:,[ugoa]*[+\-=][rwxXstugo]*)*)+)/i;
-var CHMOD_FETCH_CONTEXT = /\b(?:curl|wget)\b|\bgit\s+clone\b|\bnpx\b[^\n]{0,80}https?:\/\//i;
-var CHMOD_TARGET = /\bchmod\s+(?:-[A-Za-z]+\s+)?(?:[0-7]{3,4}|[ugoa]*(?:[+\-=][rwxXstugo]+(?:,[ugoa]*[+\-=][rwxXstugo]*)*)+)\s+(\S+)/i;
+// ../core/dist/src/security/scanner/SecurityScanner.fetch-correlation.js
+var FETCH_COMMAND_PATTERN = /\b(?:curl|wget)\b|\bgit\s+clone\b|\bnpx\b[^\n]{0,80}https?:\/\//i;
 function escapeRegExp2(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-function implicitDownloadBasename(line) {
+function normalizeCorrelationPath(raw) {
+  const cleaned = raw.replace(/['"]/g, "");
+  const isAbsolute5 = cleaned.startsWith("/");
+  const segments = [];
+  for (const segment of cleaned.split("/")) {
+    if (segment === "" || segment === ".")
+      continue;
+    if (segment === "..") {
+      const last = segments[segments.length - 1];
+      if (last !== void 0 && last !== "..")
+        segments.pop();
+      else if (!isAbsolute5)
+        segments.push("..");
+      continue;
+    }
+    segments.push(segment);
+  }
+  const base = segments.pop() ?? "";
+  return { dir: isAbsolute5 ? "/" + segments.join("/") : segments.join("/"), base };
+}
+function correlationTargetBasename(rawPath) {
+  return normalizeCorrelationPath(rawPath).base;
+}
+function directoriesCorrelate(a, b) {
+  if (a === "" || b === "")
+    return true;
+  return a === b;
+}
+function implicitDownloadDestination(line) {
   const lastSegment = (urlAfterScheme) => {
     const noFrag = urlAfterScheme.split(/[?#]/)[0];
     const slash = noFrag.indexOf("/");
@@ -21742,14 +21997,39 @@ function implicitDownloadBasename(line) {
     return lastSegment(clone2[1]).replace(/\.git$/i, "");
   const curlEq = line.match(/\bcurl\b[^\n]{0,200}?--output=['"]?(\S{1,400})/i);
   if (curlEq)
-    return curlEq[1].replace(/['"]/g, "").split("/").pop() ?? "";
+    return curlEq[1].replace(/['"]/g, "");
   return "";
 }
+function isCorrelatedWithFetchDestination(targetPath, fetchLines) {
+  const target = normalizeCorrelationPath(targetPath);
+  if (target.base === "")
+    return false;
+  const re = new RegExp(`(?:-o|-O|--output|>>?)\\s*['"]?((?:[^\\s'"]*/)?${escapeRegExp2(target.base)})(?:[\\s'"?]|$)`, "g");
+  for (const line of fetchLines) {
+    for (const match of line.matchAll(re)) {
+      if (directoriesCorrelate(target.dir, normalizeCorrelationPath(match[1]).dir))
+        return true;
+    }
+    const implicit = implicitDownloadDestination(line);
+    if (implicit === "")
+      continue;
+    const destination = normalizeCorrelationPath(implicit);
+    if (destination.base !== target.base)
+      continue;
+    if (directoriesCorrelate(target.dir, destination.dir))
+      return true;
+  }
+  return false;
+}
+
+// ../core/dist/src/security/scanner/SecurityScanner.compound.js
+var OWNER_PERM_CHMOD = /\bchmod\s+(?:-[A-Za-z]+\s+)?(?:[0-7]{3,4}|[ugoa]*(?:[+\-=][rwxXstugo]+(?:,[ugoa]*[+\-=][rwxXstugo]*)*)+)/i;
+var CHMOD_TARGET = /\bchmod\s+(?:-[A-Za-z]+\s+)?(?:[0-7]{3,4}|[ugoa]*(?:[+\-=][rwxXstugo]+(?:,[ugoa]*[+\-=][rwxXstugo]*)*)+)\s+(\S+)/i;
 function scanChmodFetchCompound(content, alreadyFlaggedLines, lineContexts) {
   const findings = [];
   const lines = content.split("\n");
   const contexts = lineContexts ?? analyzeMarkdownContext(content);
-  const fetchLines = lines.filter((l) => safeRegexTest(CHMOD_FETCH_CONTEXT, l) !== null);
+  const fetchLines = lines.filter((l) => safeRegexTest(FETCH_COMMAND_PATTERN, l) !== null);
   lines.forEach((line, index) => {
     const lineNumber = index + 1;
     if (alreadyFlaggedLines.has(lineNumber))
@@ -21758,14 +22038,13 @@ function scanChmodFetchCompound(content, alreadyFlaggedLines, lineContexts) {
     if (!match)
       return;
     const window2 = [lines[index - 1] ?? "", line, lines[index + 1] ?? ""].join("\n");
-    const adjacentFetch = safeRegexTest(CHMOD_FETCH_CONTEXT, window2) !== null;
+    const adjacentFetch = safeRegexTest(FETCH_COMMAND_PATTERN, window2) !== null;
     let correlated = false;
     const tm = safeRegexTest(CHMOD_TARGET, line);
     if (tm) {
-      const base = tm[1].replace(/['"]/g, "").split("/").pop() ?? "";
-      if (base.length >= 3) {
-        const re = new RegExp(`(?:-o|-O|--output|>>?)\\s*['"]?(?:[^\\s'"]*/)?${escapeRegExp2(base)}(?:[\\s'"?]|$)`);
-        correlated = fetchLines.some((l) => re.test(l) || implicitDownloadBasename(l) === base);
+      const targetPath = tm[1].replace(/['"]/g, "");
+      if (correlationTargetBasename(targetPath).length >= 3) {
+        correlated = isCorrelatedWithFetchDestination(targetPath, fetchLines);
       }
     }
     if (!adjacentFetch && !correlated)
@@ -21788,6 +22067,44 @@ function scanChmodFetchCompound(content, alreadyFlaggedLines, lineContexts) {
   });
   return findings;
 }
+var XATTR_CLEAR_ALL = /\bxattr\b[^\n]{0,40}-[a-zA-Z]*c[a-zA-Z]*\b/i;
+var XATTR_DELETE_QUARANTINE = /\bxattr\b[^\n]{0,40}-[a-zA-Z]*d[a-zA-Z]*\s+['"]?com\.apple\.quarantine\b/i;
+var XATTR_CLEAR_ALL_TARGET = /\bxattr\b[^\n]{0,40}-[a-zA-Z]*c[a-zA-Z]*\b\s+['"]?(\S+)/i;
+var XATTR_DELETE_QUARANTINE_TARGET = /\bxattr\b[^\n]{0,40}-[a-zA-Z]*d[a-zA-Z]*\s+['"]?com\.apple\.quarantine\b['"]?\s+['"]?(\S+)/i;
+function extractXattrTargetPath(line) {
+  const m = safeRegexTest(XATTR_CLEAR_ALL_TARGET, line) ?? safeRegexTest(XATTR_DELETE_QUARANTINE_TARGET, line);
+  if (!m)
+    return "";
+  return m[1].replace(/['"]/g, "");
+}
+function scanGatekeeperBypass(content, lineContexts, isHighTrustAuthor = false) {
+  const findings = [];
+  const lines = content.split("\n");
+  const contexts = lineContexts ?? analyzeMarkdownContext(content);
+  const fetchLines = lines.filter((l) => safeRegexTest(FETCH_COMMAND_PATTERN, l) !== null);
+  lines.forEach((line, index) => {
+    const match = safeRegexTest(XATTR_CLEAR_ALL, line) ?? safeRegexTest(XATTR_DELETE_QUARANTINE, line);
+    if (!match)
+      return;
+    const ctx = contexts[index];
+    const inInlineCode = ctx?.isInlineCode && isWithinInlineCode(line, match.index ?? 0);
+    const inDocContext = ctx ? isDocumentationContext(ctx) || inInlineCode : false;
+    const targetPath = extractXattrTargetPath(line);
+    const correlated = correlationTargetBasename(targetPath).length >= 3 && isCorrelatedWithFetchDestination(targetPath, fetchLines);
+    const critical = !inDocContext && correlated && !isHighTrustAuthor;
+    findings.push({
+      type: "gatekeeper_bypass",
+      severity: inDocContext ? "low" : critical ? "critical" : "medium",
+      message: `xattr command strips the macOS Gatekeeper quarantine attribute: "${match[0].trim().slice(0, 100)}"`,
+      location: line.trim().slice(0, 100),
+      lineNumber: index + 1,
+      category: "gatekeeper_bypass",
+      inDocumentationContext: inDocContext,
+      confidence: inDocContext ? "low" : "high"
+    });
+  });
+  return findings;
+}
 
 // ../core/dist/src/security/scanner/SecurityScanner.scanners.js
 var ENV_EXFIL_CONTEXT = /\b(?:cat|cp|mv|scp|rsync|source|curl|wget|fetch|less|more|head|tail|tee|upload|tar|zip|gzip|base64|xxd|dd|nc|netcat)\b|[|>]/i;
@@ -21950,6 +22267,541 @@ function scanPrivilegeEscalation(content, lineContexts) {
   return findings;
 }
 
+// ../core/dist/src/security/scanner/SecurityScanner.archive.js
+var UNZIP_INVOCATION = /\bunzip\b[^\n]{0,200}/i;
+var UNRAR_INVOCATION = /\bunrar\s+x\b[^\n]{0,200}/i;
+var SEVENZIP_INVOCATION = /\b7z\s+x\b[^\n]{0,200}/i;
+var ZIP_INVOCATION = /\bzip\b[^\n]{0,200}/i;
+var UNZIP_PASSWORD_ARG = /-P\s+(\S{1,200})/;
+var UNRAR_SEVENZIP_PASSWORD_ARG = /-p(\S{1,200})/i;
+var ZIP_PASSWORD_ARG = /-P\s+(\S{1,200})/;
+var ZIP_ENCRYPT_FLAG = /(?:^|\s)-e(?:\s|$)/;
+var ARCHIVE_FILENAME = /(\S+\.(?:zip|rar|7z|tar\.gz|tgz))\b/i;
+function findArchiveCliPassword(line) {
+  const unzip = safeRegexTest(UNZIP_INVOCATION, line);
+  if (unzip) {
+    const pw = safeRegexTest(UNZIP_PASSWORD_ARG, unzip[0]);
+    if (pw)
+      return { tool: "unzip", password: pw[1], index: unzip.index ?? 0 };
+  }
+  const unrar = safeRegexTest(UNRAR_INVOCATION, line);
+  if (unrar) {
+    const pw = safeRegexTest(UNRAR_SEVENZIP_PASSWORD_ARG, unrar[0]);
+    if (pw)
+      return { tool: "unrar", password: pw[1], index: unrar.index ?? 0 };
+  }
+  const sevenZip = safeRegexTest(SEVENZIP_INVOCATION, line);
+  if (sevenZip) {
+    const pw = safeRegexTest(UNRAR_SEVENZIP_PASSWORD_ARG, sevenZip[0]);
+    if (pw)
+      return { tool: "7z", password: pw[1], index: sevenZip.index ?? 0 };
+  }
+  const zip = safeRegexTest(ZIP_INVOCATION, line);
+  if (zip) {
+    const pw = safeRegexTest(ZIP_PASSWORD_ARG, zip[0]);
+    if (pw && safeRegexCheck(ZIP_ENCRYPT_FLAG, zip[0])) {
+      return { tool: "zip", password: pw[1], index: zip.index ?? 0 };
+    }
+  }
+  return null;
+}
+function extractArchiveTargetPath(line) {
+  const m = safeRegexTest(ARCHIVE_FILENAME, line);
+  if (!m)
+    return "";
+  return m[1].replace(/['"]/g, "");
+}
+var SHELL_VAR_REF = /^\$\{?[A-Za-z_][A-Za-z0-9_]*\}?$/;
+function isInlineLiteralPassword(password2) {
+  if (!password2)
+    return false;
+  const unquoted = password2.replace(/^['"]|['"]$/g, "");
+  if (safeRegexCheck(SHELL_VAR_REF, unquoted))
+    return false;
+  return !looksLikePlaceholderSecret(unquoted);
+}
+var ARCHIVE_NOUN = /\b(?:zip|rar|7z|tar\.gz|tgz|archive)\b/i;
+var PASSWORD_NOUN = /\bpassword\b|\bpasscode\b|\bpassphrase\b/i;
+function findArchivePasswordProseLines(lines) {
+  const flagged = /* @__PURE__ */ new Set();
+  lines.forEach((line, index) => {
+    if (!safeRegexCheck(ARCHIVE_NOUN, line))
+      return;
+    const start = Math.max(0, index - 2);
+    const end = Math.min(lines.length - 1, index + 2);
+    for (let i = start; i <= end; i++) {
+      if (safeRegexCheck(PASSWORD_NOUN, lines[i])) {
+        flagged.add(index + 1);
+        break;
+      }
+    }
+  });
+  return Array.from(flagged);
+}
+function scanArchiveEvasion(content, lineContexts) {
+  const findings = [];
+  const lines = content.split("\n");
+  const contexts = lineContexts ?? analyzeMarkdownContext(content);
+  const fetchLines = lines.filter((l) => safeRegexTest(FETCH_COMMAND_PATTERN, l) !== null);
+  const emittedLines = /* @__PURE__ */ new Set();
+  lines.forEach((line, index) => {
+    const lineNumber = index + 1;
+    const cli = findArchiveCliPassword(line);
+    if (!cli)
+      return;
+    const ctx = contexts[index];
+    const inInlineCode = ctx?.isInlineCode && isWithinInlineCode(line, cli.index);
+    const inDocContext = ctx ? isDocumentationContext(ctx) || inInlineCode : false;
+    const inlineLiteral = isInlineLiteralPassword(cli.password);
+    const targetPath = extractArchiveTargetPath(line);
+    const correlated = correlationTargetBasename(targetPath).length >= 3 && isCorrelatedWithFetchDestination(targetPath, fetchLines);
+    const critical = !inDocContext && inlineLiteral && correlated;
+    findings.push({
+      type: "archive_evasion",
+      severity: inDocContext ? "low" : critical ? "critical" : "medium",
+      message: `Password-protected archive CLI usage (${cli.tool}): "${line.trim().slice(0, 100)}"`,
+      location: line.trim().slice(0, 100),
+      lineNumber,
+      category: "archive_evasion",
+      inDocumentationContext: inDocContext,
+      confidence: inDocContext ? "low" : "high"
+    });
+    emittedLines.add(lineNumber);
+  });
+  for (const lineNumber of findArchivePasswordProseLines(lines)) {
+    if (emittedLines.has(lineNumber))
+      continue;
+    const ctx = contexts[lineNumber - 1];
+    const inDocContext = ctx ? isDocumentationContext(ctx) : false;
+    findings.push({
+      type: "archive_evasion",
+      severity: inDocContext ? "low" : "medium",
+      message: `Archive and password mentioned in close proximity: "${lines[lineNumber - 1].trim().slice(0, 100)}"`,
+      location: lines[lineNumber - 1].trim().slice(0, 100),
+      lineNumber,
+      category: "archive_evasion",
+      inDocumentationContext: inDocContext,
+      confidence: inDocContext ? "low" : "medium"
+    });
+  }
+  return findings;
+}
+
+// ../core/dist/src/security/scanner/SecurityScanner.paste-host.js
+var ANON_PASTE_HOST_SET = new Set([...ANON_PASTE_HOSTS, ...URL_SHORTENER_DOMAINS].map((d) => d.toLowerCase()));
+var TRANSIENT_TRANSFER_HOST_SET = new Set(TRANSIENT_TRANSFER_HOSTS.map((d) => d.toLowerCase()));
+function classifyPasteHostTier(url2) {
+  let hostname7;
+  try {
+    hostname7 = new URL(url2).hostname.toLowerCase();
+  } catch {
+    return null;
+  }
+  const matchesSet = (set2) => {
+    for (const domain2 of set2) {
+      if (hostname7 === domain2 || hostname7.endsWith("." + domain2))
+        return true;
+    }
+    return false;
+  };
+  if (matchesSet(ANON_PASTE_HOST_SET))
+    return "anon";
+  if (matchesSet(TRANSIENT_TRANSFER_HOST_SET))
+    return "transient";
+  return null;
+}
+var FETCH_VERB_PATTERN = /\b(?:curl|wget)\b/i;
+var PIPE_TO_INTERPRETER_TAIL = /^\|\s*(?:sudo\s+(?:-[A-Za-z]+\s+)?)?(?:(?:ba|z|da)?sh|python[23]?|node|ruby|perl|php|fish|bun|deno)\b/i;
+function isDirectPipeToInterpreter(url2, lineContent) {
+  const pipeIndex = lineContent.indexOf("|");
+  if (pipeIndex < 0)
+    return false;
+  const beforePipe = lineContent.slice(0, pipeIndex);
+  if (!beforePipe.includes(url2))
+    return false;
+  if (!safeRegexCheck(FETCH_VERB_PATTERN, beforePipe))
+    return false;
+  return safeRegexCheck(PIPE_TO_INTERPRETER_TAIL, lineContent.slice(pipeIndex));
+}
+var NPX_DIRECT_EXEC_PATTERN = /\bnpx\b[^\n]{0,80}https?:\/\//i;
+var FETCH_VERB_TOKENS = /* @__PURE__ */ new Set(["curl", "wget", "npx"]);
+var FLAG_TOKEN = /^-{1,2}[A-Za-z][\w-]*$/;
+var VALUE_TAKING_FLAGS = /* @__PURE__ */ new Set([
+  "-o",
+  "-x",
+  "-h",
+  "-d",
+  "-a",
+  "-e",
+  "-u",
+  "-b",
+  "--output",
+  "--request",
+  "--header",
+  "--data",
+  "--data-raw",
+  "--data-binary",
+  "--data-urlencode",
+  "--user-agent",
+  "--referer",
+  "--proxy",
+  "--cookie"
+]);
+function bareToken(token) {
+  return token.replace(/^[^A-Za-z0-9/.-]+/, "").replace(/[^A-Za-z0-9/._-]+$/, "").toLowerCase();
+}
+function isFetchVerbArgument(prefix) {
+  const segment = prefix.split(/[;|&]/).pop() ?? "";
+  const tokens = segment.trim().split(/\s+/).map(bareToken).filter((t) => t.length > 0);
+  let afterVerb = -1;
+  for (let i = 0; i < tokens.length; i++) {
+    if (tokens[i] === "git" && tokens[i + 1] === "clone")
+      afterVerb = i + 2;
+    else if (FETCH_VERB_TOKENS.has(tokens[i]))
+      afterVerb = i + 1;
+  }
+  if (afterVerb < 0)
+    return false;
+  for (let i = afterVerb; i < tokens.length; i++) {
+    const token = tokens[i];
+    if (!safeRegexCheck(FLAG_TOKEN, token))
+      return false;
+    if (VALUE_TAKING_FLAGS.has(token) && i + 1 < tokens.length)
+      i++;
+  }
+  return true;
+}
+function isActualFetchTarget(lineContent, url2) {
+  for (let from = 0; ; ) {
+    const urlIndex = lineContent.indexOf(url2, from);
+    if (urlIndex < 0)
+      return false;
+    if (isFetchVerbArgument(lineContent.slice(0, urlIndex)))
+      return true;
+    from = urlIndex + 1;
+  }
+}
+var CHMOD_TARGET2 = /\bchmod\s+(?:-[A-Za-z]+\s+)?(?:[0-7]{3,4}|[ugoa]*(?:[+\-=][rwxXstugo]+(?:,[ugoa]*[+\-=][rwxXstugo]*)*)+)\s+(\S+)/i;
+var DIRECT_EXEC_TARGET = /\b(?:sudo\s+)?(?:(?:ba|z|da)?sh|python[23]?|node|ruby|perl|php|fish|bun|deno)\s+(\.{0,2}\/?[\w-]+(?:[./][\w-]+)*)/i;
+var DOT_SLASH_EXEC_TARGET = /(?:^|[\s;&|])\.\/([\w-]+(?:[./][\w-]+)*)/;
+var SOURCE_TARGET = /(?:^|[;&|]\s*)source\s+(\.{0,2}\/?[\w-]+(?:[./][\w-]+)+)/i;
+var EXEC_TARGET_PATTERNS = [
+  CHMOD_TARGET2,
+  DIRECT_EXEC_TARGET,
+  DOT_SLASH_EXEC_TARGET,
+  SOURCE_TARGET
+];
+function collectExecTargetPaths(lines) {
+  const paths = [];
+  for (const line of lines) {
+    for (const pattern of EXEC_TARGET_PATTERNS) {
+      const m = safeRegexTest(pattern, line);
+      if (!m?.[1])
+        continue;
+      const targetPath = m[1].replace(/['"]/g, "");
+      if (correlationTargetBasename(targetPath).length >= 3)
+        paths.push(targetPath);
+    }
+  }
+  return paths;
+}
+function isExecutedElsewhereCorrelated(fetchLine, execTargetPaths) {
+  return execTargetPaths.some((path27) => isCorrelatedWithFetchDestination(path27, [fetchLine]));
+}
+function scanPasteHostFetch(content, lineContexts) {
+  const findings = [];
+  const lines = content.split("\n");
+  const contexts = lineContexts ?? analyzeMarkdownContext(content);
+  const urls = extractUrls(content);
+  const execTargetPaths = collectExecTargetPaths(lines);
+  for (const { url: url2, line } of urls) {
+    const tier = classifyPasteHostTier(url2);
+    if (!tier)
+      continue;
+    const lineIndex = line - 1;
+    const lineContent = lines[lineIndex] ?? "";
+    if (!isActualFetchTarget(lineContent, url2))
+      continue;
+    const ctx = contexts[lineIndex];
+    const inDocContext = ctx ? isDocumentationContext(ctx) : false;
+    if (tier === "transient") {
+      findings.push({
+        type: "paste_host_fetch",
+        severity: inDocContext ? "low" : "medium",
+        message: `Ephemeral file-transfer host URL fetched (never standalone-critical by design): ${url2}`,
+        location: lineContent.trim().slice(0, 100),
+        lineNumber: line,
+        category: "paste_host_fetch",
+        inDocumentationContext: inDocContext,
+        confidence: inDocContext ? "low" : "medium"
+      });
+      continue;
+    }
+    const executed = isDirectPipeToInterpreter(url2, lineContent) || safeRegexCheck(NPX_DIRECT_EXEC_PATTERN, lineContent) || isExecutedElsewhereCorrelated(lineContent, execTargetPaths);
+    if (!executed)
+      continue;
+    findings.push({
+      type: "paste_host_fetch",
+      // Standalone-critical (execution evidence required, see above) — doc
+      // context is the only downgrade, matching every other detector's
+      // noise-reduction convention in this Wave.
+      severity: inDocContext ? "low" : "critical",
+      message: `Paste/snippet-host URL is the target of an execution instruction: ${url2}`,
+      location: lineContent.trim().slice(0, 100),
+      lineNumber: line,
+      category: "paste_host_fetch",
+      inDocumentationContext: inDocContext,
+      confidence: inDocContext ? "low" : "high"
+    });
+  }
+  return findings;
+}
+
+// ../core/dist/src/security/scanner/SecurityScanner.encoding.js
+var MAX_ENCODED_CANDIDATE_BYTES = 2e5;
+var MAX_OVERSIZED_ADVISORIES = 8;
+var MAX_BASE64_CANDIDATES = 8;
+var MAX_DECODED_TOTAL_BYTES = 256e3;
+var BASE64_CANDIDATE = /[A-Za-z0-9+/]{120,}={0,2}/g;
+var DATA_URI_LOOKBACK = 60;
+var DATA_URI_PREFIX = /data:(?:image|font|audio)\//i;
+var CONTROL_CHAR = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/;
+var MIN_PRINTABLE_RATIO = 0.9;
+function tryDecodeBase64ToPlausibleText(candidate) {
+  let binary;
+  try {
+    binary = atob(candidate);
+  } catch {
+    return null;
+  }
+  if (binary.length === 0)
+    return null;
+  if (btoa(binary).replace(/=+$/, "") !== candidate.replace(/=+$/, ""))
+    return null;
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++)
+    bytes[i] = binary.charCodeAt(i);
+  let text;
+  try {
+    text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  } catch {
+    return null;
+  }
+  if (text.length === 0)
+    return null;
+  let controlCount = 0;
+  for (const ch of text) {
+    if (CONTROL_CHAR.test(ch))
+      controlCount++;
+  }
+  const printableRatio = (text.length - controlCount) / text.length;
+  if (printableRatio < MIN_PRINTABLE_RATIO)
+    return null;
+  return text;
+}
+function scanEncodedPayload(content, lineContexts, rescan) {
+  const findings = [];
+  const lines = content.split("\n");
+  const contexts = lineContexts ?? analyzeMarkdownContext(content);
+  let candidatesProcessed = 0;
+  let decodedTotalBytes = 0;
+  let aggregateBudgetExhausted = false;
+  let oversizedAdvisories = 0;
+  lines.forEach((line, index) => {
+    const lineNumber = index + 1;
+    for (const match of line.matchAll(BASE64_CANDIDATE)) {
+      const candidate = match[0];
+      const start = match.index ?? 0;
+      const before = line.slice(Math.max(0, start - DATA_URI_LOOKBACK), start);
+      if (DATA_URI_PREFIX.test(before))
+        continue;
+      if (candidate.length > MAX_ENCODED_CANDIDATE_BYTES) {
+        if (oversizedAdvisories >= MAX_OVERSIZED_ADVISORIES)
+          continue;
+        oversizedAdvisories++;
+        const oversizeCtx = contexts[index];
+        const oversizeInInlineCode = oversizeCtx?.isInlineCode && isWithinInlineCode(line, start);
+        const oversizeInDocContext = oversizeCtx ? isDocumentationContext(oversizeCtx) || oversizeInInlineCode : false;
+        findings.push({
+          type: "encoded_payload",
+          severity: "low",
+          message: `Base64-encoded payload exceeds the ${MAX_ENCODED_CANDIDATE_BYTES}-byte per-candidate cap \u2014 oversized candidate, not decoded/rescanned (${candidate.length} chars)`,
+          location: line.trim().slice(0, 100),
+          lineNumber,
+          category: "encoded_payload",
+          inDocumentationContext: oversizeInDocContext,
+          confidence: "low"
+        });
+        continue;
+      }
+      if (candidatesProcessed >= MAX_BASE64_CANDIDATES || aggregateBudgetExhausted)
+        continue;
+      candidatesProcessed++;
+      const decoded = tryDecodeBase64ToPlausibleText(candidate);
+      if (decoded === null)
+        continue;
+      const decodedByteLength = new TextEncoder().encode(decoded).length;
+      if (decodedTotalBytes + decodedByteLength > MAX_DECODED_TOTAL_BYTES) {
+        aggregateBudgetExhausted = true;
+        continue;
+      }
+      decodedTotalBytes += decodedByteLength;
+      const ctx = contexts[index];
+      const inInlineCode = ctx?.isInlineCode && isWithinInlineCode(line, start);
+      const inDocContext = ctx ? isDocumentationContext(ctx) || inInlineCode : false;
+      findings.push({
+        type: "encoded_payload",
+        // Advisory-tier only (weights.ts: 1.2 / 0.04, the sensitive_path/
+        // typosquat tier) — see module header for why this is deliberately
+        // NOT the 2.0/0.40 tier the other three Wave 2 detectors use.
+        severity: inDocContext ? "low" : "medium",
+        message: `Base64-encoded payload decoded and rescanned (${candidate.length} chars)`,
+        location: line.trim().slice(0, 100),
+        lineNumber,
+        category: "encoded_payload",
+        inDocumentationContext: inDocContext,
+        confidence: inDocContext ? "low" : "high"
+      });
+      for (const inner of rescan(decoded)) {
+        findings.push({ ...inner, decodedFrom: lineNumber });
+      }
+    }
+  });
+  return findings;
+}
+
+// ../core/dist/src/security/scanner/SecurityScanner.decoy.js
+var DECOY_WINDOW_LINES = 5;
+var DECOY_AUTHORITY_AFFIX_PROXIMITY_LINES = 0;
+var FETCH_VERBS = /* @__PURE__ */ new Set(["curl", "wget", "npx"]);
+var FLAG_TOKEN2 = /^-{1,2}[A-Za-z][\w-]*$/;
+var VALUE_TAKING_FLAGS2 = /* @__PURE__ */ new Set([
+  "-o",
+  "-x",
+  "-h",
+  "-d",
+  "-a",
+  "-e",
+  "-u",
+  "-b",
+  "--output",
+  "--request",
+  "--header",
+  "--data",
+  "--data-raw",
+  "--data-binary",
+  "--data-urlencode",
+  "--user-agent",
+  "--referer",
+  "--proxy",
+  "--cookie"
+]);
+function isActualFetchTarget2(lineContent, url2) {
+  const urlIndex = lineContent.indexOf(url2);
+  if (urlIndex < 0)
+    return false;
+  const prefix = lineContent.slice(0, urlIndex);
+  if (/[;|&]/.test(prefix))
+    return false;
+  const tokens = prefix.trim().split(/\s+/).filter((t) => t.length > 0);
+  if (tokens.length === 0)
+    return false;
+  let i;
+  if (tokens[0]?.toLowerCase() === "git" && tokens[1]?.toLowerCase() === "clone") {
+    i = 2;
+  } else if (FETCH_VERBS.has(tokens[0]?.toLowerCase() ?? "")) {
+    i = 1;
+  } else {
+    return false;
+  }
+  for (; i < tokens.length; i++) {
+    const token = tokens[i];
+    if (!FLAG_TOKEN2.test(token))
+      return false;
+    if (VALUE_TAKING_FLAGS2.has(token.toLowerCase()) && i + 1 < tokens.length) {
+      i++;
+    }
+  }
+  return true;
+}
+var BRAND_CANONICAL_DOMAINS = {
+  anthropic: ["anthropic.com", "claude.ai"],
+  claude: ["anthropic.com", "claude.ai"],
+  gemini: ["google.com", "ai.google.dev", "deepmind.google"],
+  copilot: ["github.com", "microsoft.com"],
+  vercel: ["vercel.com"],
+  salesforce: ["salesforce.com"]
+};
+function tokenize(raw) {
+  return raw.toLowerCase().split(/[^a-z0-9]+/i).filter((t) => t.length > 0);
+}
+function matchesDomainSet(hostname7, domains) {
+  return domains.some((d) => hostname7 === d || hostname7.endsWith("." + d));
+}
+function findVendorClaimInWindow(lines, lineIndex) {
+  const start = Math.max(0, lineIndex - DECOY_WINDOW_LINES);
+  const end = Math.min(lines.length - 1, lineIndex + DECOY_WINDOW_LINES);
+  let brandToken = null;
+  let brandLineIndex = -1;
+  for (let i = start; i <= end && !brandToken; i++) {
+    for (const token of tokenize(lines[i] ?? "")) {
+      if (Object.prototype.hasOwnProperty.call(BRAND_ALIASES, token)) {
+        brandToken = token;
+        brandLineIndex = i;
+        break;
+      }
+    }
+  }
+  if (!brandToken)
+    return null;
+  const affixStart = Math.max(0, brandLineIndex - DECOY_AUTHORITY_AFFIX_PROXIMITY_LINES);
+  const affixEnd = Math.min(lines.length - 1, brandLineIndex + DECOY_AUTHORITY_AFFIX_PROXIMITY_LINES);
+  const hasAuthorityAffix = tokenize(lines.slice(affixStart, affixEnd + 1).join(" ")).some((t) => AUTHORITY_CLAIMING_AFFIXES.has(t));
+  return { brandToken, hasAuthorityAffix };
+}
+function scanDecoyMisdirection(content, lineContexts) {
+  const findings = [];
+  const lines = content.split("\n");
+  const contexts = lineContexts ?? analyzeMarkdownContext(content);
+  const urls = extractUrls(content);
+  for (const { url: url2, line } of urls) {
+    const lineIndex = line - 1;
+    const lineContent = lines[lineIndex] ?? "";
+    if (!isActualFetchTarget2(lineContent, url2))
+      continue;
+    let hostname7;
+    try {
+      hostname7 = new URL(url2).hostname.toLowerCase();
+    } catch {
+      continue;
+    }
+    const claim = findVendorClaimInWindow(lines, lineIndex);
+    if (!claim)
+      continue;
+    const canonicalDomains = BRAND_CANONICAL_DOMAINS[claim.brandToken] ?? [];
+    if (matchesDomainSet(hostname7, canonicalDomains))
+      continue;
+    if (matchesDomainSet(hostname7, DEFAULT_ALLOWED_DOMAINS))
+      continue;
+    const ctx = contexts[lineIndex];
+    const inDocContext = ctx ? isDocumentationContext(ctx) : false;
+    findings.push({
+      type: "decoy_misdirection",
+      // Never high/critical — an approximate NL heuristic by construction
+      // (plan §9 reconciliation table); the escalation-into-code_execution
+      // co-signal mechanism lives in a separate dispatch.
+      severity: inDocContext ? "low" : "medium",
+      message: `Fetch target domain ("${hostname7}") does not match the "${claim.brandToken}" vendor claimed nearby in the skill's own prose: ${url2}`,
+      location: lineContent.trim().slice(0, 100),
+      lineNumber: line,
+      category: "decoy_misdirection",
+      inDocumentationContext: inDocContext,
+      confidence: inDocContext ? "low" : claim.hasAuthorityAffix ? "high" : "medium"
+    });
+  }
+  return findings;
+}
+
 // ../core/dist/src/security/scanner/SecurityScanner.js
 var SecurityScanner = class {
   allowedDomains;
@@ -21962,18 +22814,6 @@ var SecurityScanner = class {
     this.maxContentLength = options.maxContentLength ?? 1e6;
     this.riskThreshold = options.riskThreshold ?? 40;
   }
-  extractUrls(content) {
-    const urlPattern = /https?:\/\/[^\s<>"')\]]+/gi;
-    const lines = content.split("\n");
-    const results = [];
-    lines.forEach((line, index) => {
-      let match;
-      while ((match = urlPattern.exec(line)) !== null) {
-        results.push({ url: match[0], line: index + 1 });
-      }
-    });
-    return results;
-  }
   isAllowedDomain(url2) {
     try {
       const parsed = new URL(url2);
@@ -21985,7 +22825,7 @@ var SecurityScanner = class {
   }
   scanUrls(content) {
     const findings = [];
-    const urls = this.extractUrls(content);
+    const urls = extractUrls(content);
     for (const { url: url2, line } of urls) {
       if (!this.isAllowedDomain(url2)) {
         findings.push({
@@ -22066,25 +22906,25 @@ var SecurityScanner = class {
   }
   /** @deprecated Use standalone calculateRiskScore function for new code */
   calculateRiskScore = calculateRiskScore;
-  scan(skillId, content) {
-    const startTime = performance.now();
+  /**
+   * Run every content-scanning detector against `content` and return the
+   * combined findings. Factored out of `scan()` (SMI-6033 Wave 2, Gap 2) so
+   * the encoded-payload detector's recursive rescan of DECODED content can
+   * reuse the exact same detector suite instead of a parallel, narrower
+   * reimplementation.
+   *
+   * `skipEncodedPayload` is the STRUCTURAL depth-1 recursion guarantee: the
+   * recursive callback passed to `scanEncodedPayload` below always calls this
+   * method with `skipEncodedPayload: true`, so a base64 blob discovered
+   * INSIDE already-decoded content can never itself be decoded — the inner
+   * call cannot reach `scanEncodedPayload` again no matter what the decoded
+   * text contains. This disables ONLY the encoded-payload detector on the
+   * inner call, not the rest of the suite — a decoded `curl|bash` still
+   * trips `code_execution`, decoded secrets still trip `sensitive_path`, etc.
+   */
+  runDetectors(content, lineContexts, skipEncodedPayload, isHighTrustAuthor = false, isMarkdown = true) {
     const findings = [];
-    const lineContexts = analyzeMarkdownContext(content);
-    if (content.length > this.maxContentLength) {
-      findings.push({
-        type: "suspicious_pattern",
-        severity: "low",
-        message: `Content exceeds maximum length (${this.maxContentLength} code units)`
-      });
-    }
     const effectiveMultilineLimit = Math.min(MAX_CONTENT_LENGTH_FOR_REGEX, this.maxContentLength);
-    if (content.length > effectiveMultilineLimit) {
-      findings.push({
-        type: "suspicious_pattern",
-        severity: "low",
-        message: `Multiline regex scan truncated at ${effectiveMultilineLimit} code units (content is ${content.length} code units; configured maxContentLength is ${this.maxContentLength} code units)`
-      });
-    }
     findings.push(...this.scanUrls(content));
     findings.push(...scanSensitivePaths(content, lineContexts));
     findings.push(...this.scanJailbreakPatterns(content, lineContexts, effectiveMultilineLimit));
@@ -22095,6 +22935,10 @@ var SecurityScanner = class {
     findings.push(...scanPrivilegeEscalation(content, lineContexts));
     const privEscLines = new Set(findings.filter((f) => f.type === "privilege_escalation" && f.lineNumber).map((f) => f.lineNumber));
     findings.push(...scanChmodFetchCompound(content, privEscLines, lineContexts));
+    findings.push(...scanGatekeeperBypass(content, lineContexts, isHighTrustAuthor));
+    findings.push(...scanArchiveEvasion(content, lineContexts));
+    findings.push(...scanPasteHostFetch(content, lineContexts));
+    findings.push(...scanDecoyMisdirection(content, lineContexts));
     findings.push(...this.scanAIDefenceVulnerabilities(content, lineContexts, effectiveMultilineLimit));
     findings.push(...scanSsrfPatterns(content, lineContexts, effectiveMultilineLimit));
     findings.push(...scanPiiPatterns(content, lineContexts));
@@ -22102,6 +22946,50 @@ var SecurityScanner = class {
     findings.push(...scanObfuscatedDirective(content));
     escalateCodeExecution(findings);
     escalateCorroboratedMentions(findings);
+    if (!skipEncodedPayload) {
+      findings.push(...scanEncodedPayload(content, lineContexts, (decodedContent) => this.runDetectors(decodedContent, analyzeMarkdownContext(decodedContent, isMarkdown), true, isHighTrustAuthor, isMarkdown)));
+    }
+    return findings;
+  }
+  /**
+   * SMI-6033 Wave 3 (Gap 5): `isHighTrustAuthor` (default `false`) is the
+   * Gatekeeper-bypass trust-tier carve-out — see `scanGatekeeperBypass`'s own
+   * header (`SecurityScanner.compound.ts`) for the full policy. No in-repo
+   * caller of this method currently has a verified author signal to pass
+   * here (the indexer scans via the edge twin, not this core class); the
+   * parameter exists so a future verified-author caller can opt in, and so
+   * every existing call site (skill_validate, skill_rescan,
+   * bundled-sibling-scan, skill-installation.*) defaults closed by
+   * construction, not by convention.
+   *
+   * SMI-6033 Wave 2 (Gap 8) fix (2026-08-17): `isMarkdown` defaults `true`,
+   * preserving byte-identical behavior for every existing caller. Pass
+   * `false` when `content` is a real source file, not markdown — see
+   * `analyzeMarkdownContext`'s own header (SecurityScanner.helpers.ts) for
+   * why the markdown-only indented-code-block heuristic must never apply to
+   * non-markdown content. `bundled-sibling-scan.ts`'s
+   * `collectExecutableCodeFiles` candidates are the first real caller.
+   */
+  scan(skillId, content, isHighTrustAuthor = false, isMarkdown = true) {
+    const startTime = performance.now();
+    const findings = [];
+    const lineContexts = analyzeMarkdownContext(content, isMarkdown);
+    if (content.length > this.maxContentLength) {
+      findings.push({
+        type: "suspicious_pattern",
+        severity: "low",
+        message: `Content exceeds maximum length (${this.maxContentLength} code units)`
+      });
+    }
+    const effectiveMultilineLimit = Math.min(MAX_CONTENT_LENGTH_FOR_REGEX, this.maxContentLength);
+    if (content.length > effectiveMultilineLimit) {
+      findings.push({
+        type: "suspicious_pattern",
+        severity: "low",
+        message: `Multiline regex scan truncated at ${effectiveMultilineLimit} code units (content is ${content.length} code units; configured maxContentLength is ${this.maxContentLength} code units)`
+      });
+    }
+    findings.push(...this.runDetectors(content, lineContexts, false, isHighTrustAuthor, isMarkdown));
     const endTime = performance.now();
     const { total: riskScore, breakdown: riskBreakdown } = calculateRiskScore(findings);
     const hasCritical = findings.some((f) => f.severity === "critical");
@@ -24429,10 +25317,10 @@ function isBetterSqlite3Available() {
 
 // ../core/dist/src/db/drivers/sqljsDriver.js
 import { createRequire as createRequire2 } from "node:module";
-import { existsSync as existsSync13, readFileSync as readFileSync10, writeFileSync as writeFileSync10, renameSync as renameSync3, unlinkSync as unlinkSync3 } from "node:fs";
+import { existsSync as existsSync14, readFileSync as readFileSync11, writeFileSync as writeFileSync11, renameSync as renameSync3, unlinkSync as unlinkSync3 } from "node:fs";
 
 // ../core/dist/src/db/drivers/corruption.js
-import { existsSync as existsSync12, renameSync as renameSync2 } from "node:fs";
+import { existsSync as existsSync13, renameSync as renameSync2 } from "node:fs";
 var CORRUPTION_MARKERS = [
   "sqlite_corrupt",
   "malformed",
@@ -24448,7 +25336,7 @@ function backupCorruptDbFile(path27) {
   if (path27 === ":memory:") {
     throw new Error("[Skillsmith] backupCorruptDbFile: cannot back up an in-memory database");
   }
-  if (!existsSync12(path27)) {
+  if (!existsSync13(path27)) {
     throw new Error(`[Skillsmith] backupCorruptDbFile: file does not exist: ${path27}`);
   }
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
@@ -24666,11 +25554,11 @@ var SqlJsDatabaseAdapter = class {
     const data = this.db.export();
     const tmpPath = `${this.filePath}.tmp`;
     try {
-      writeFileSync10(tmpPath, Buffer.from(data));
+      writeFileSync11(tmpPath, Buffer.from(data));
       renameSync3(tmpPath, this.filePath);
     } catch (error46) {
       try {
-        if (existsSync13(tmpPath))
+        if (existsSync14(tmpPath))
           unlinkSync3(tmpPath);
       } catch {
       }
@@ -24707,8 +25595,8 @@ var SqlJsDatabaseAdapter = class {
 async function createSqlJsDatabase(path27 = ":memory:", options) {
   const SQL = await loadSqlJs();
   let data;
-  if (path27 !== ":memory:" && existsSync13(path27)) {
-    data = readFileSync10(path27);
+  if (path27 !== ":memory:" && existsSync14(path27)) {
+    data = readFileSync11(path27);
   } else if (path27 !== ":memory:" && options?.fileMustExist) {
     throw new Error(`SQLITE_CANTOPEN: unable to open database file: ${path27}`);
   }
@@ -24728,7 +25616,7 @@ async function createSqlJsDatabase(path27 = ":memory:", options) {
       } catch {
       }
     }
-    if (!isCorruptionError(error46) || path27 === ":memory:" || !existsSync13(path27)) {
+    if (!isCorruptionError(error46) || path27 === ":memory:" || !existsSync14(path27)) {
       throw error46;
     }
     const backupPath = backupCorruptDbFile(path27);
@@ -24892,7 +25780,7 @@ function findSimilarBruteForceFromMap(embeddings, queryEmbedding, topK) {
 }
 
 // ../core/dist/src/embeddings/hnsw-search.js
-import { existsSync as existsSync14, mkdirSync as mkdirSync8, readFileSync as readFileSync11, renameSync as renameSync4, unlinkSync as unlinkSync4, writeFileSync as writeFileSync11 } from "fs";
+import { existsSync as existsSync15, mkdirSync as mkdirSync8, readFileSync as readFileSync12, renameSync as renameSync4, unlinkSync as unlinkSync4, writeFileSync as writeFileSync12 } from "fs";
 import { dirname as dirname13, join as join22 } from "path";
 var cachedCtor = null;
 async function loadHnswCtor() {
@@ -24928,10 +25816,10 @@ function cachePaths(modelName) {
   };
 }
 function readMeta(metaPath) {
-  if (!existsSync14(metaPath))
+  if (!existsSync15(metaPath))
     return null;
   try {
-    const parsed = JSON.parse(readFileSync11(metaPath, "utf-8"));
+    const parsed = JSON.parse(readFileSync12(metaPath, "utf-8"));
     if (parsed.version !== 1)
       return null;
     return parsed;
@@ -24940,10 +25828,10 @@ function readMeta(metaPath) {
   }
 }
 function readLabels(labelsPath) {
-  if (!existsSync14(labelsPath))
+  if (!existsSync15(labelsPath))
     return null;
   try {
-    const parsed = JSON.parse(readFileSync11(labelsPath, "utf-8"));
+    const parsed = JSON.parse(readFileSync12(labelsPath, "utf-8"));
     if (!Array.isArray(parsed))
       return null;
     return parsed;
@@ -24953,7 +25841,7 @@ function readLabels(labelsPath) {
 }
 function writeAtomic(tmp, final, contents) {
   mkdirSync8(dirname13(tmp), { recursive: true });
-  writeFileSync11(tmp, contents, typeof contents === "string" ? { encoding: "utf-8" } : void 0);
+  writeFileSync12(tmp, contents, typeof contents === "string" ? { encoding: "utf-8" } : void 0);
   renameSync4(tmp, final);
 }
 async function loadOrBuildHnsw(args) {
@@ -24972,7 +25860,7 @@ async function loadOrBuildHnsw(args) {
   const efConstruction = args.efConstruction ?? 400;
   const efSearch = args.efSearch ?? 200;
   const capacity = Math.max(args.maxElements ?? Math.max(count * 2, 1024), 1024);
-  const reusable = meta3 !== null && labels !== null && meta3.modelName === args.modelName && meta3.dim === args.dim && meta3.count === count && existsSync14(paths.bin);
+  const reusable = meta3 !== null && labels !== null && meta3.modelName === args.modelName && meta3.dim === args.dim && meta3.count === count && existsSync15(paths.bin);
   let index;
   let labelToId;
   let idToLabel;
@@ -24987,11 +25875,11 @@ async function loadOrBuildHnsw(args) {
       nextLabel = labels.reduce((max, [label]) => Math.max(max, label), -1) + 1;
     } catch (err) {
       try {
-        if (existsSync14(paths.bin))
+        if (existsSync15(paths.bin))
           unlinkSync4(paths.bin);
-        if (existsSync14(paths.meta))
+        if (existsSync15(paths.meta))
           unlinkSync4(paths.meta);
-        if (existsSync14(paths.labels))
+        if (existsSync15(paths.labels))
           unlinkSync4(paths.labels);
       } catch {
       }
@@ -25051,7 +25939,7 @@ function createHandle(args) {
       clearTimeout(timer);
       timer = null;
     }
-    if (!dirty && existsSync14(args.paths.bin) && existsSync14(args.paths.meta)) {
+    if (!dirty && existsSync15(args.paths.bin) && existsSync15(args.paths.meta)) {
       return;
     }
     args.index.writeIndexSync(args.paths.binTmp);
@@ -26497,7 +27385,7 @@ function redactSensitiveObject(obj, seen = /* @__PURE__ */ new WeakSet()) {
 }
 
 // ../core/dist/src/logging/rotation.js
-import { createWriteStream, existsSync as existsSync15, statSync as statSync2 } from "node:fs";
+import { createWriteStream, existsSync as existsSync16, statSync as statSync2 } from "node:fs";
 import { mkdir as mkdir2, readdir as readdir2, stat, unlink as unlink2 } from "node:fs/promises";
 import { homedir as homedir10 } from "node:os";
 import { join as join23 } from "node:path";
@@ -26517,7 +27405,7 @@ function dailyFilePath(surface, date5) {
 function nextRolledFilePath(surface, date5) {
   const base = dailyFilePath(surface, date5);
   let n = 1;
-  while (existsSync15(`${base}.${n}`))
+  while (existsSync16(`${base}.${n}`))
     n++;
   return `${base}.${n}`;
 }
@@ -26618,7 +27506,7 @@ function writeLogLine(surface, line) {
 async function pruneExpiredLogs() {
   const dir = getLogDir();
   try {
-    if (!existsSync15(dir))
+    if (!existsSync16(dir))
       return;
     const entries = await readdir2(dir);
     const cutoff = Date.now() - RETENTION_DAYS * 24 * 60 * 60 * 1e3;
@@ -27015,7 +27903,7 @@ async function buildInventoryPayload(opts) {
 // ../core/dist/src/config/token-credentials.js
 import { homedir as homedir11 } from "os";
 import { join as join25 } from "path";
-import { existsSync as existsSync16, readFileSync as readFileSync12, writeFileSync as writeFileSync12, chmodSync as chmodSync6 } from "fs";
+import { existsSync as existsSync17, readFileSync as readFileSync13, writeFileSync as writeFileSync13, chmodSync as chmodSync6 } from "fs";
 
 // ../core/dist/src/api/utils.js
 function calculateBackoff(attempt, baseDelay = 1e3) {
@@ -27048,10 +27936,10 @@ function getConfigPath2() {
 }
 function readConfigFile() {
   const p = getConfigPath2();
-  if (!existsSync16(p))
+  if (!existsSync17(p))
     return {};
   try {
-    return JSON.parse(readFileSync12(p, "utf-8"));
+    return JSON.parse(readFileSync13(p, "utf-8"));
   } catch {
     return {};
   }
@@ -27059,7 +27947,7 @@ function readConfigFile() {
 function writeConfigFile(data) {
   ensureConfigDir();
   const p = getConfigPath2();
-  writeFileSync12(p, JSON.stringify(data, null, 2), { encoding: "utf-8", mode: 384 });
+  writeFileSync13(p, JSON.stringify(data, null, 2), { encoding: "utf-8", mode: 384 });
   try {
     chmodSync6(p, 384);
   } catch {
@@ -27118,6 +28006,46 @@ async function loadCredentials() {
     version: 2
   };
 }
+async function clearCredentials() {
+  const sources = [];
+  let keyringError;
+  const keytar = await getKeytar2();
+  if (keytar) {
+    try {
+      const deleted = await keytar.deletePassword(KEYTAR_SERVICE2, KEYTAR_ACCOUNT_REFRESH);
+      if (deleted) {
+        sources.push("keyring");
+      }
+    } catch (err) {
+      keyringError = err instanceof Error ? err.message : String(err);
+    }
+  }
+  const configPath2 = getConfigPath2();
+  ensureConfigDir();
+  const release = acquireConfigLock(configPath2);
+  try {
+    const existing = readConfigFile();
+    delete existing.accessToken;
+    delete existing.refreshToken;
+    delete existing.expiresAt;
+    delete existing.version;
+    atomicWriteFile(configPath2, JSON.stringify(existing, null, 2), 384);
+  } finally {
+    release();
+  }
+  sources.push("config file");
+  if (keyringError) {
+    return {
+      success: false,
+      source: sources.join(" and "),
+      error: keyringError
+    };
+  }
+  return {
+    success: true,
+    source: sources.join(" and ")
+  };
+}
 async function refreshAccessToken(refreshToken) {
   try {
     const resp = await fetch(`${SUPABASE_AUTH_URL}/token?grant_type=refresh_token`, {
@@ -27726,7 +28654,7 @@ function addInferredMcp(inferred, declaredMcpServers, result) {
 
 // ../core/dist/src/services/skill-installation.helpers.js
 import * as fs5 from "fs/promises";
-import { existsSync as existsSync17, readFileSync as readFileSync13 } from "fs";
+import { existsSync as existsSync18, readFileSync as readFileSync14 } from "fs";
 import * as path4 from "path";
 import { createHash as createHash7 } from "crypto";
 
@@ -28159,10 +29087,10 @@ async function ensureDirNoFollow(dirPath) {
   }
 }
 async function mkdirNoFollow(baseDir, dir) {
-  const relative8 = path3.relative(baseDir, dir);
-  if (relative8 === "" || relative8.startsWith(".."))
+  const relative10 = path3.relative(baseDir, dir);
+  if (relative10 === "" || relative10.startsWith(".."))
     return;
-  const segments = relative8.split(path3.sep);
+  const segments = relative10.split(path3.sep);
   let current = baseDir;
   for (const segment of segments) {
     current = path3.join(current, segment);
@@ -28298,10 +29226,10 @@ function generateTips(skillName, optimizationInfo, client = CANONICAL_CLIENT, sk
 }
 function getRegisteredMcpServers(projectRoot = process.cwd()) {
   const mcpJsonPath = path4.join(projectRoot, ".mcp.json");
-  if (!existsSync17(mcpJsonPath))
+  if (!existsSync18(mcpJsonPath))
     return void 0;
   try {
-    const raw = readFileSync13(mcpJsonPath, "utf-8");
+    const raw = readFileSync14(mcpJsonPath, "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object")
       return void 0;
@@ -29282,7 +30210,7 @@ function buildEmptyStackGuidance() {
   return "No technology stack could be derived for recommendations \u2014 this usually means a non-Node project, a stack with no production dependencies, or an unsupported language, not a backend or registry problem. Provide project context (a short description of the project or its tooling) or an explicit list of installed/currently-used skills, then try again.";
 }
 function getRecommendAutoDetectedFooterText() {
-  return "auto-detected from your installed skills across all clients";
+  return "auto-detected from your installed skills";
 }
 
 // ../core/dist/src/services/context-words.js
@@ -31543,6 +32471,11 @@ var ApiSearchResultSchema = external_exports.object({
   last_scanned_at: external_exports.string().nullable().optional(),
   security_findings: external_exports.array(external_exports.unknown()).nullable().optional(),
   quarantined: external_exports.boolean().optional(),
+  // SMI-6033 Wave 2 (Gap 8): partial-scan coverage columns. Declared here so
+  // Zod does not strip them before get-skill.ts / search.ts read them (same
+  // reason as compatibility/license below).
+  scan_coverage_incomplete: external_exports.boolean().optional(),
+  scan_coverage_note: external_exports.string().nullable().optional(),
   // SMI-5327: SPDX license surfaced by skills-get / skills-search. Declared here
   // so Zod does not strip the field before get-skill.ts / search.ts read it
   // (same reason as compatibility above). skills-search may omit it → optional.
@@ -32098,7 +33031,12 @@ function deriveSecuritySummaryFromApiSkill(apiSkill) {
     passed: apiSkill.quarantined === true ? false : apiSkill.security_score == null ? null : true,
     riskScore: apiSkill.security_score ?? null,
     findingsCount: Array.isArray(apiSkill.security_findings) ? apiSkill.security_findings.length : 0,
-    scannedAt: apiSkill.last_scanned_at
+    scannedAt: apiSkill.last_scanned_at,
+    // SMI-6033 Wave 2 (Gap 8): default to complete coverage when the column
+    // is absent (older cached rows / pre-Wave-2 API responses) — never
+    // fabricate an incomplete-scan caveat for data that predates this field.
+    scanCoverageIncomplete: apiSkill.scan_coverage_incomplete ?? false,
+    scanCoverageNote: apiSkill.scan_coverage_note ?? null
   };
 }
 
@@ -33159,11 +34097,11 @@ function defaultParseFrontmatter(content) {
     const line = rawLine.trim();
     if (!line || line.startsWith("#"))
       continue;
-    const sep6 = line.indexOf(":");
-    if (sep6 === -1)
+    const sep7 = line.indexOf(":");
+    if (sep7 === -1)
       continue;
-    const key = line.slice(0, sep6).trim();
-    const value = line.slice(sep6 + 1).trim();
+    const key = line.slice(0, sep7).trim();
+    const value = line.slice(sep7 + 1).trim();
     assignKey(result, key, value);
   }
   return result;
@@ -33584,7 +34522,7 @@ var SourceRecoveryService = class {
 };
 
 // ../core/dist/src/provenance/backfill.js
-import { existsSync as existsSync19 } from "fs";
+import { existsSync as existsSync20 } from "fs";
 import * as fs11 from "fs/promises";
 import * as os4 from "os";
 import * as path13 from "path";
@@ -33683,7 +34621,7 @@ function mergeEntry(existing, planned) {
   };
 }
 async function maybeWriteFrontmatter(dir, sourceUrl) {
-  if (existsSync19(path13.join(dir, ".git", "config")))
+  if (existsSync20(path13.join(dir, ".git", "config")))
     return false;
   const skillMdPath = path13.join(dir, "SKILL.md");
   let content;
@@ -33906,7 +34844,7 @@ async function probeEmbeddingCapability(opts = {}) {
 }
 
 // src/version.ts
-import { readFileSync as readFileSync17 } from "node:fs";
+import { readFileSync as readFileSync18 } from "node:fs";
 import { join as join39 } from "node:path";
 
 // src/utils/package-root.ts
@@ -33920,7 +34858,7 @@ function packageRoot() {
 function readVersion() {
   try {
     const pkgPath = join39(packageRoot(), "package.json");
-    const pkg = JSON.parse(readFileSync17(pkgPath, "utf-8"));
+    const pkg = JSON.parse(readFileSync18(pkgPath, "utf-8"));
     return pkg.version ?? "0.0.0";
   } catch {
     return "0.0.0";
@@ -33938,7 +34876,7 @@ function getCliLogger() {
 }
 
 // src/utils/open-database.ts
-import { existsSync as existsSync20 } from "node:fs";
+import { existsSync as existsSync21 } from "node:fs";
 var logger8 = getCliLogger();
 async function openCliDatabase(path27, options) {
   if (options?.readonly) {
@@ -33950,7 +34888,7 @@ async function openCliDatabase(path27, options) {
     initializeSchema(db);
     return db;
   } catch (err) {
-    if (!isCorruptionError(err) || path27 === ":memory:" || !existsSync20(path27)) {
+    if (!isCorruptionError(err) || path27 === ":memory:" || !existsSync21(path27)) {
       throw err;
     }
     if (db) {
@@ -34772,10 +35710,19 @@ import { dirname as dirname20 } from "path";
 // src/utils/skills-directory.ts
 import { readdir as readdir6, readFile as readFile6, realpath as realpath3, stat as stat6 } from "fs/promises";
 import { createHash as createHash8 } from "crypto";
-import { join as join40 } from "path";
+import { join as join41 } from "path";
+
+// src/utils/local-skills-dir.ts
+import { join as join40, relative as relative7, sep as sep5 } from "path";
+var LOCAL_SKILLS_DIR_SEGMENTS = [".claude", "skills"];
 function getLocalSkillsDir() {
-  return join40(process.cwd(), ".claude", "skills");
+  return join40(process.cwd(), ...LOCAL_SKILLS_DIR_SEGMENTS);
 }
+function getLocalSkillsDirDisplay() {
+  return `./${relative7(process.cwd(), getLocalSkillsDir()).split(sep5).join("/")}`;
+}
+
+// src/utils/skills-directory.ts
 async function resolvesToDirectory2(entryPath, isDirectory, isSymbolicLink) {
   if (isDirectory) return true;
   if (!isSymbolicLink) return false;
@@ -34802,14 +35749,14 @@ async function getSkillsFromDirectory(skillsDir, dbPath, installedVia = CANONICA
     const entries = await readdir6(skillsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.name.startsWith(".")) continue;
-      const skillPath = join40(skillsDir, entry.name);
+      const skillPath = join41(skillsDir, entry.name);
       const isSkillDir = await resolvesToDirectory2(
         skillPath,
         entry.isDirectory(),
         entry.isSymbolicLink?.() ?? false
       );
       if (isSkillDir) {
-        const skillMdPath = join40(skillPath, "SKILL.md");
+        const skillMdPath = join41(skillPath, "SKILL.md");
         try {
           const skillMdStat = await stat6(skillMdPath);
           const content = await readFile6(skillMdPath, "utf-8");
@@ -34878,7 +35825,7 @@ async function safeRealpath2(p) {
 }
 async function readSkillMd(skillPath) {
   try {
-    const content = await readFile6(join40(skillPath, "SKILL.md"), "utf-8");
+    const content = await readFile6(join41(skillPath, "SKILL.md"), "utf-8");
     const contentHash = createHash8("sha256").update(content, "utf8").digest("hex");
     const parser2 = new SkillParser();
     const parsed = parser2.parse(content);
@@ -34984,15 +35931,15 @@ async function getInstalledSkillsForClient(client, dbPath) {
 import { confirm } from "@inquirer/prompts";
 import ora3 from "ora";
 import { readFile as readFile8 } from "fs/promises";
-import { basename as basename6, join as join42 } from "path";
+import { basename as basename6, join as join43 } from "path";
 
 // src/utils/manifest.ts
 import { createHash as createHash9, randomUUID as randomUUID7 } from "crypto";
 import { readFile as readFile7, writeFile as writeFile4, mkdir as mkdir5, rename as rename3, unlink as unlink5 } from "fs/promises";
-import { join as join41, dirname as dirname19 } from "path";
+import { join as join42, dirname as dirname19 } from "path";
 import { homedir as homedir18 } from "os";
-var SKILLSMITH_DIR = join41(homedir18(), ".skillsmith");
-var MANIFEST_PATH = join41(SKILLSMITH_DIR, "manifest.json");
+var SKILLSMITH_DIR = join42(homedir18(), ".skillsmith");
+var MANIFEST_PATH = join42(SKILLSMITH_DIR, "manifest.json");
 async function loadManifest2() {
   try {
     const content = await readFile7(MANIFEST_PATH, "utf-8");
@@ -35100,7 +36047,7 @@ var AUTO_APPLY_RECOVERY_CONFIDENCES = /* @__PURE__ */ new Set([
 async function recoverConfidentSourceId(skillName, installed, db) {
   let skillMd;
   try {
-    skillMd = await readFile8(join42(installed.path, "SKILL.md"), "utf-8");
+    skillMd = await readFile8(join43(installed.path, "SKILL.md"), "utf-8");
   } catch {
     skillMd = null;
   }
@@ -35120,6 +36067,16 @@ async function recoverConfidentSourceId(skillName, installed, db) {
   }
   return result.recoveredSource?.url ?? result.registryId ?? null;
 }
+async function readClaimedAuthor(installedPath) {
+  try {
+    const skillMd = await readFile8(join43(installedPath, "SKILL.md"), "utf-8");
+    const parsed = new SkillParser().parse(skillMd);
+    const author = parsed?.["author"];
+    return typeof author === "string" && author.trim().length > 0 ? author.trim() : null;
+  } catch {
+    return null;
+  }
+}
 async function getSkillDiff(skillName, dbPath, client = CANONICAL_CLIENT) {
   const installed = (await getInstalledSkillsForClient(client, dbPath)).find(
     (s) => s.name.toLowerCase() === skillName.toLowerCase()
@@ -35131,9 +36088,13 @@ async function getSkillDiff(skillName, dbPath, client = CANONICAL_CLIENT) {
   const skillRepo = new SkillRepository(db);
   try {
     const allSkills = skillRepo.findAll(1e3, 0);
-    const skill = allSkills.items.find(
+    const claimedAuthor = await readClaimedAuthor(installed.path);
+    const nameMatches = allSkills.items.filter(
       (s) => s.name.toLowerCase() === skillName.toLowerCase()
     );
+    const skill = claimedAuthor ? nameMatches.find(
+      (s) => s.author && s.author.toLowerCase() === claimedAuthor.toLowerCase()
+    ) : void 0;
     if (skill) {
       const changes = [];
       const skillWithVersion = skill;
@@ -35347,7 +36308,7 @@ function displaySkillsTable(skills, client = CANONICAL_CLIENT) {
   console.log(
     source_default.dim(
       `
-${skills.length} skill(s) found (global: ${getInstallPath(client)}, local: ./.claude/skills)
+${skills.length} skill(s) found (global: ${getInstallPath(client)}, local: ${getLocalSkillsDirDisplay()})
 `
     )
   );
@@ -35550,7 +36511,7 @@ var InitSkillError = class _InitSkillError extends Error {
 import { input as input2, confirm as confirm3, select as select2 } from "@inquirer/prompts";
 import ora5 from "ora";
 import { mkdir as mkdir9, writeFile as writeFile6, readFile as readFile9, stat as stat7, readdir as readdir7 } from "fs/promises";
-import { dirname as dirname21, join as join44, resolve as resolve12 } from "path";
+import { dirname as dirname21, join as join45, resolve as resolve12 } from "path";
 import { createHash as createHash10 } from "crypto";
 
 // src/utils/skill-name.ts
@@ -35655,7 +36616,7 @@ function validateSubagentDefinition(content) {
 
 // src/commands/author/init.helpers.ts
 import { mkdir as mkdir8, writeFile as writeFile5, rm as rm4 } from "fs/promises";
-import { join as join43 } from "path";
+import { join as join44 } from "path";
 
 // src/templates/skill.md.template.ts
 var SKILL_MD_TEMPLATE = `---
@@ -36044,11 +37005,22 @@ var CLIENT_SNIPPETS = {
     // SMI-5894 Wave 1 Step 7: SKILLSMITH_CLIENT tells the server to install
     // to ~/.cursor/skills instead of the default ~/.claude/skills — without
     // it, Cursor users silently get Claude Code's install path.
+    //
+    // SMI-5893 Wave 11 (GH#2368 C-01): `command` is a resolved-path
+    // placeholder, not `npx` — Cursor's bundled Node cannot resolve `npx`
+    // packages (a real ENOENT on a missing Resources/app/resources/lib
+    // directory), confirmed by an external tester hitting this on two
+    // separate live UAT passes even after `npx` carried strong caveat text.
+    // A guessed default path (e.g. a Homebrew-style tab) can *also* be
+    // wrong for an nvm/asdf/custom-prefix install, which fails silently
+    // differently instead of predictably — so this deliberately never
+    // guesses a path at all; the primary copied snippet can never be wrong,
+    // only require one resolve-and-paste step. `npx` stays available as an
+    // explicit, clearly-labeled fallback in `notes` below, not removed.
     body: `{
   "mcpServers": {
     "{{name}}": {
-      "command": "npx",
-      "args": ["-y", "{{name}}"],
+      "command": "<paste output of: which {{name}} (macOS/Linux) or where {{name}} (Windows)>",
       "env": {
         "SKILLSMITH_API_KEY": "sk_live_...",
         "SKILLSMITH_CLIENT": "cursor"
@@ -36056,7 +37028,14 @@ var CLIENT_SNIPPETS = {
     }
   }
 }`,
-    notes: "Cursor 2.4+ required. Reload the window after saving. Recommended: `npm install -g {{name}}` first, then point `command` at the installed `skillsmith-mcp` binary (run `which skillsmith-mcp` after installing to get the exact path \u2014 it varies by platform/npm prefix, e.g. `/opt/homebrew/bin/skillsmith-mcp` on macOS/Homebrew, a different path on Linux/Windows). The `npx -y {{name}}` form above still works as a fallback, but re-resolves the package on every launch \u2014 expect a slower cold start, and watch for EBADENGINE (Cursor bundles its own Node, sometimes older than the >=22.22 this package requires) or ENOTEMPTY errors on repeated installs."
+    // Assumes the package's `bin` name matches its npm package name — true for
+    // every server scaffolded by mcp-server.template.ts (PACKAGE_JSON_TEMPLATE's
+    // `bin` field is literally `{{name}}`), the only production caller of this
+    // matrix today. The real @skillsmith/mcp-server package is the one exception
+    // (bin is the shorter `skillsmith-mcp`, not the scoped package name) — its
+    // docs are hand-maintained separately (root README, packages/mcp-server/README.md,
+    // website's mcp-client-snippets.ts) rather than rendered through this file.
+    notes: 'Cursor 2.4+ required, Node >=22.22 (Cursor\'s own bundled Node meets this). Setup: run `npm install -g {{name}}`, then run `which {{name}}` (macOS/Linux) or `where {{name}}` (Windows) and paste that path into `command` above \u2014 Cursor\'s bundled Node cannot resolve packages via `npx` (a real ENOENT on a missing Resources/app/resources/lib directory), so pointing directly at the installed binary is the only form confirmed to work inside Cursor. Prefer to try `npx` first anyway? Replace `command` with `"npx"` and add `"args": ["-y", "{{name}}"]` \u2014 simpler, but may hit the same ENOENT, plus EBADENGINE or ENOTEMPTY on repeated installs. After saving: enable the server in Cursor\'s Settings -> MCP panel and start a new chat \u2014 a correctly-configured entry still shows disconnected until toggled on there \u2014 then reload the window.'
   },
   copilot: {
     label: "GitHub Copilot (VS Code)",
@@ -36205,9 +37184,10 @@ function renderAllSnippetsAsMarkdown(packageName) {
   const sections = Object.keys(CLIENT_SNIPPETS).map((id) => {
     const snippet = CLIENT_SNIPPETS[id];
     const body = renderSnippet(id, packageName);
-    const notes = snippet.notes ? `
+    const renderedNotes = snippet.notes?.replace(/\{\{name\}\}/g, packageName);
+    const notes = renderedNotes ? `
 
-${snippet.notes}` : "";
+${renderedNotes}` : "";
     return [
       `<details>`,
       `<summary><strong>${snippet.label}</strong> \u2014 \`${snippet.configPath}\`</summary>`,
@@ -36577,15 +37557,15 @@ function renderMcpServerTemplates(data) {
 async function scaffoldSkillDirectory(input7) {
   const { skillDir, skillName, description, author, category, createdFresh } = input7;
   try {
-    await mkdir8(join43(skillDir, "scripts"), { recursive: true });
-    await mkdir8(join43(skillDir, "resources"), { recursive: true });
+    await mkdir8(join44(skillDir, "scripts"), { recursive: true });
+    await mkdir8(join44(skillDir, "resources"), { recursive: true });
     const skillMdContent = SKILL_MD_TEMPLATE.replace(/\{\{name\}\}/g, skillName).replace(/\{\{description\}\}/g, description).replace(/\{\{author\}\}/g, author).replace(/\{\{category\}\}/g, category).replace(/\{\{date\}\}/g, (/* @__PURE__ */ new Date()).toISOString().split("T")[0] || "").replace(/\{\{behavioralClassification\}\}/g, "");
-    await writeFile5(join43(skillDir, "SKILL.md"), skillMdContent, "utf-8");
+    await writeFile5(join44(skillDir, "SKILL.md"), skillMdContent, "utf-8");
     const readmeContent = README_MD_TEMPLATE.replace(/\{\{name\}\}/g, skillName).replace(
       /\{\{description\}\}/g,
       description
     );
-    await writeFile5(join43(skillDir, "README.md"), readmeContent, "utf-8");
+    await writeFile5(join44(skillDir, "README.md"), readmeContent, "utf-8");
     const placeholderScript = `#!/usr/bin/env node
 /**
  * ${skillName} - Example Script
@@ -36595,7 +37575,7 @@ async function scaffoldSkillDirectory(input7) {
 
 console.log('${skillName} script executed');
 `;
-    await writeFile5(join43(skillDir, "scripts", "example.js"), placeholderScript, "utf-8");
+    await writeFile5(join44(skillDir, "scripts", "example.js"), placeholderScript, "utf-8");
     const gitignore = `# Dependencies
 node_modules/
 
@@ -36610,7 +37590,7 @@ dist/
 .DS_Store
 Thumbs.db
 `;
-    await writeFile5(join43(skillDir, ".gitignore"), gitignore, "utf-8");
+    await writeFile5(join44(skillDir, ".gitignore"), gitignore, "utf-8");
     return { ok: true };
   } catch (error46) {
     await rollbackPartialScaffold(skillDir, createdFresh);
@@ -36726,11 +37706,11 @@ async function validateSkill(skillPath) {
     try {
       const stats = await stat7(filePath);
       if (stats.isDirectory()) {
-        filePath = join44(filePath, "SKILL.md");
+        filePath = join45(filePath, "SKILL.md");
       }
     } catch {
       if (!filePath.endsWith(".md")) {
-        filePath = join44(filePath, "SKILL.md");
+        filePath = join45(filePath, "SKILL.md");
       }
     }
     const content = await readFile9(filePath, "utf-8");
@@ -36777,7 +37757,7 @@ async function publishSkill(skillPath, options = {}) {
       spinner.fail(`Directory not found: ${dirPath}`);
       return false;
     }
-    const skillMdPath = join44(dirPath, "SKILL.md");
+    const skillMdPath = join45(dirPath, "SKILL.md");
     spinner.text = "Validating skill...";
     const content = await readFile9(skillMdPath, "utf-8");
     const parser2 = new SkillParser({ requireName: true });
@@ -36823,7 +37803,7 @@ async function publishSkill(skillPath, options = {}) {
       }).filter((p) => p !== null);
       let totalWarnings = 0;
       for (const mdFile of mdFiles) {
-        const filePath = join44(dirPath, mdFile);
+        const filePath = join45(dirPath, mdFile);
         const fileContent = await readFile9(filePath, "utf-8");
         const result = SkillParser.checkReferences(fileContent, customPatterns);
         if (result.matches.length > 0) {
@@ -36852,7 +37832,7 @@ async function publishSkill(skillPath, options = {}) {
         spinner.start();
       }
     }
-    const manifestPath = join44(dirPath, ".skillsmith-publish.json");
+    const manifestPath = join45(dirPath, ".skillsmith-publish.json");
     await writeFile6(manifestPath, JSON.stringify(publishInfo, null, 2), "utf-8");
     spinner.succeed("Skill prepared for publishing");
     console.log(source_default.bold("\nPublish Information:"));
@@ -36959,7 +37939,7 @@ function createPublishCommand() {
 import { Command as Command5 } from "commander";
 import ora6 from "ora";
 import { readFile as readFile10, writeFile as writeFile7, stat as stat8 } from "fs/promises";
-import { basename as basename7, dirname as dirname22, join as join45, resolve as resolve13 } from "path";
+import { basename as basename7, dirname as dirname22, join as join46, resolve as resolve13 } from "path";
 
 // src/utils/tool-analyzer.ts
 var TOOL_PATTERNS3 = {
@@ -37088,13 +38068,13 @@ async function generateSubagent2(skillPath, options) {
     try {
       const stats = await stat8(dirPath);
       if (stats.isDirectory()) {
-        skillMdPath = join45(dirPath, "SKILL.md");
+        skillMdPath = join46(dirPath, "SKILL.md");
       } else {
         skillMdPath = dirPath;
         dirPath = dirname22(dirPath);
       }
     } catch {
-      skillMdPath = dirPath.endsWith(".md") ? dirPath : join45(dirPath, "SKILL.md");
+      skillMdPath = dirPath.endsWith(".md") ? dirPath : join46(dirPath, "SKILL.md");
     }
     spinner.text = "Reading SKILL.md...";
     const content = await readFile10(skillMdPath, "utf-8");
@@ -37145,7 +38125,7 @@ async function generateSubagent2(skillPath, options) {
       "{name}",
       basename7(metadata.name)
     );
-    const subagentPath = join45(agentsDir, subagentFilename);
+    const subagentPath = join46(agentsDir, subagentFilename);
     if (await fileExists(subagentPath)) {
       if (!options.force) {
         spinner.warn(`Subagent already exists: ${subagentPath}`);
@@ -37212,7 +38192,7 @@ function createSubagentCommand() {
 import { Command as Command6 } from "commander";
 import ora7 from "ora";
 import { readFile as readFile11, readdir as readdir8 } from "fs/promises";
-import { join as join46, resolve as resolve14 } from "path";
+import { join as join47, resolve as resolve14 } from "path";
 var logger14 = getCliLogger();
 async function transformSkill2(skillPath, options) {
   const spinner = ora7("Transforming skill...").start();
@@ -37227,9 +38207,9 @@ async function transformSkill2(skillPath, options) {
         const subdirs = await readdir8(dirPath, { withFileTypes: true });
         for (const entry of subdirs) {
           if (entry.isDirectory()) {
-            const skillMdPath2 = join46(dirPath, entry.name, "SKILL.md");
+            const skillMdPath2 = join47(dirPath, entry.name, "SKILL.md");
             if (await fileExists(skillMdPath2)) {
-              skillDirs.push(join46(dirPath, entry.name));
+              skillDirs.push(join47(dirPath, entry.name));
             }
           }
         }
@@ -37251,7 +38231,7 @@ Processing: ${skillDir}`));
       }
       return;
     }
-    const skillMdPath = join46(dirPath, "SKILL.md");
+    const skillMdPath = join47(dirPath, "SKILL.md");
     if (!await fileExists(skillMdPath)) {
       spinner.fail(`No SKILL.md found at: ${skillMdPath}`);
       throw new Error(`No SKILL.md found at: ${skillMdPath}`);
@@ -37323,7 +38303,7 @@ import { Command as Command7 } from "commander";
 import { input as input3, confirm as confirm4 } from "@inquirer/prompts";
 import ora8 from "ora";
 import { mkdir as mkdir10, writeFile as writeFile8, stat as stat9 } from "fs/promises";
-import { dirname as dirname23, join as join47, resolve as resolve15 } from "path";
+import { dirname as dirname23, join as join48, resolve as resolve15 } from "path";
 var logger15 = getCliLogger();
 async function initMcpServer(name, options) {
   const serverName = name || await input3({
@@ -37436,10 +38416,10 @@ async function initMcpServer(name, options) {
       author
     });
     await mkdir10(targetDir, { recursive: true });
-    await mkdir10(join47(targetDir, "src"), { recursive: true });
-    await mkdir10(join47(targetDir, "src", "tools"), { recursive: true });
+    await mkdir10(join48(targetDir, "src"), { recursive: true });
+    await mkdir10(join48(targetDir, "src", "tools"), { recursive: true });
     for (const [filePath, content] of files) {
-      const fullPath = join47(targetDir, filePath);
+      const fullPath = join48(targetDir, filePath);
       const dir = dirname23(fullPath);
       await mkdir10(dir, { recursive: true });
       await writeFile8(fullPath, content, "utf-8");
@@ -37459,7 +38439,7 @@ async function initMcpServer(name, options) {
   "mcpServers": {
     "${serverName}": {
       "command": "npx",
-      "args": ["tsx", "${join47(targetDir, "src", "index.ts")}"]
+      "args": ["tsx", "${join48(targetDir, "src", "index.ts")}"]
     }
   }
 }`)
@@ -37640,8 +38620,8 @@ import { Command as Command9 } from "commander";
 import ora9 from "ora";
 
 // src/commands/recommend.helpers.ts
-import { existsSync as existsSync21, readdirSync as readdirSync2, readFileSync as readFileSync18, statSync as statSync4 } from "node:fs";
-import { join as join48 } from "node:path";
+import { existsSync as existsSync22, readdirSync as readdirSync2, readFileSync as readFileSync19, statSync as statSync4 } from "node:fs";
+import { join as join49 } from "node:path";
 
 // src/commands/recommend.types.ts
 var VALID_TRUST_TIERS = [
@@ -37971,14 +38951,14 @@ function buildStackFromAnalysis(context) {
 }
 function getInstalledSkills2() {
   const skillsDir = getCanonicalInstallPath();
-  if (!existsSync21(skillsDir)) {
+  if (!existsSync22(skillsDir)) {
     return [];
   }
   const installedSkills = [];
   try {
     const entries = readdirSync2(skillsDir);
     for (const entry of entries) {
-      const skillPath = join48(skillsDir, entry);
+      const skillPath = join49(skillsDir, entry);
       const stat13 = statSync4(skillPath);
       if (!stat13.isDirectory()) continue;
       const skill = {
@@ -37987,10 +38967,10 @@ function getInstalledSkills2() {
         tags: [],
         category: null
       };
-      const skillMdPath = join48(skillPath, "SKILL.md");
-      if (existsSync21(skillMdPath)) {
+      const skillMdPath = join49(skillPath, "SKILL.md");
+      if (existsSync22(skillMdPath)) {
         try {
-          const content = readFileSync18(skillMdPath, "utf-8");
+          const content = readFileSync19(skillMdPath, "utf-8");
           const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
           const frontmatter = frontmatterMatch?.[1];
           if (frontmatter) {
@@ -38645,7 +39625,7 @@ function createSyncCommand() {
 // src/commands/merge.ts
 import { Command as Command11 } from "commander";
 import { resolve as resolve16 } from "path";
-import { existsSync as existsSync22 } from "fs";
+import { existsSync as existsSync23 } from "fs";
 var logger19 = getCliLogger();
 function formatMergeResult(result) {
   const lines = [
@@ -38679,11 +39659,11 @@ async function mergeActionImpl(sourcePath, targetPath, options) {
   }
   const resolvedSource = resolve16(sourcePath);
   const resolvedTarget = targetPath ? resolve16(targetPath) : getDefaultDbPath();
-  if (!existsSync22(resolvedSource)) {
+  if (!existsSync23(resolvedSource)) {
     logger19.error(`Source database not found: ${resolvedSource}`);
     process.exit(1);
   }
-  if (!existsSync22(resolvedTarget)) {
+  if (!existsSync23(resolvedTarget)) {
     logger19.error(`Target database not found: ${resolvedTarget}`);
     logger19.error("Create a new database first with: skillsmith init");
     process.exit(1);
@@ -38948,13 +39928,13 @@ function createRegistryCommand() {
 import { Command as Command13 } from "commander";
 import ora12 from "ora";
 import { mkdir as mkdir11, copyFile as copyFile2, stat as stat10, readdir as readdir9 } from "fs/promises";
-import { join as join49, dirname as dirname24 } from "path";
+import { join as join50, dirname as dirname24 } from "path";
 var logger21 = getCliLogger();
 function getAssetsPath() {
-  return join49(packageRoot(), "assets", "skillsmith-skill");
+  return join50(packageRoot(), "assets", "skillsmith-skill");
 }
 function getTargetPath(client) {
-  return join49(getInstallPath(client), "skillsmith");
+  return join50(getInstallPath(client), "skillsmith");
 }
 async function directoryExists(path27) {
   try {
@@ -38971,8 +39951,8 @@ async function copyDirectory(src, dest) {
     if (entry.isSymbolicLink()) {
       continue;
     }
-    const srcPath = join49(src, entry.name);
-    const destPath = join49(dest, entry.name);
+    const srcPath = join50(src, entry.name);
+    const destPath = join50(dest, entry.name);
     if (entry.isDirectory()) {
       await mkdir11(destPath, { recursive: true });
       filesCopied += await copyDirectory(srcPath, destPath);
@@ -39350,28 +40330,34 @@ import { Command as Command15 } from "commander";
 import { confirm as confirm5 } from "@inquirer/prompts";
 async function logoutActionImpl() {
   const status = await getAuthStatus();
-  if (!status.authenticated) {
+  const jwtSession = await loadCredentials();
+  const hasJwtSession = jwtSession !== null;
+  if (!status.authenticated && !hasJwtSession) {
     console.log("Not authenticated. Nothing to log out.");
     process.exit(0);
   }
   const confirmed = await confirm5({
-    message: "Log out and remove stored API key?",
+    message: "Log out and remove stored credentials?",
     default: false
   });
   if (!confirmed) {
     console.log("Cancelled.");
     process.exit(0);
   }
-  const result = await clearApiKey();
-  if (result.success) {
-    console.log(source_default.green(`Logged out. Key removed from ${result.source}.`));
+  const apiKeyResult = await clearApiKey();
+  const jwtResult = await clearCredentials();
+  const results = [apiKeyResult, jwtResult];
+  if (results.every((r) => r.success)) {
+    const sources = [...new Set(results.flatMap((r) => r.source.split(" and ")))].join(" and ");
+    console.log(source_default.green(`Logged out. Credentials removed from ${sources}.`));
   } else {
-    console.log(
-      source_default.yellow(
-        `Logged out (config file cleared), but could not remove from keyring: ${result.error}`
-      )
-    );
-    console.log(source_default.dim("The key may still be stored in your OS keyring."));
+    console.log(source_default.yellow("Logged out (config file cleared), but with keyring warnings:"));
+    for (const result of results) {
+      if (!result.success) {
+        console.log(source_default.yellow(`  Could not remove from keyring: ${result.error}`));
+      }
+    }
+    console.log(source_default.dim("Some credentials may still be stored in your OS keyring."));
   }
   process.exit(0);
 }
@@ -39381,7 +40367,7 @@ var logoutAction = withTelemetry(logoutActionImpl, {
   extractFramework: () => "cli"
 });
 function createLogoutCommand() {
-  return new Command15("logout").description("Remove stored Skillsmith API key").action(logoutAction);
+  return new Command15("logout").description("Remove stored Skillsmith credentials").action(logoutAction);
 }
 
 // src/commands/whoami.ts
@@ -39393,6 +40379,17 @@ var SOURCE_LABELS = {
   none: "none"
 };
 async function whoamiActionImpl() {
+  const jwtSession = await loadCredentials();
+  if (jwtSession) {
+    console.log(source_default.bold("Skillsmith CLI"));
+    console.log(source_default.dim("  Session: ") + source_default.cyan("device-code login"));
+    const expired = Date.now() >= jwtSession.expiresAt;
+    const expiresLabel = new Date(jwtSession.expiresAt).toLocaleString();
+    console.log(
+      source_default.dim("  Access token: ") + (expired ? source_default.yellow(`expired ${expiresLabel} (refreshes automatically on next use)`) : source_default.green(`valid until ${expiresLabel}`))
+    );
+    process.exit(0);
+  }
   const status = await getAuthStatus();
   if (!status.authenticated || !status.keyPrefix) {
     console.log(`Not authenticated. Run ${source_default.cyan("`skillsmith login`")} to authenticate.`);
@@ -39424,7 +40421,7 @@ function createWhoamiCommand() {
 // src/commands/diff.ts
 import { Command as Command17 } from "commander";
 import { readFile as readFile12 } from "fs/promises";
-import { join as join50 } from "path";
+import { join as join51 } from "path";
 
 // src/utils/license-types.ts
 var TIER_FEATURES = {
@@ -39554,7 +40551,7 @@ var TIER_PRICING = {
   community: "$0/month",
   individual: "$9.99/month",
   team: "$25/user/month",
-  enterprise: "$55/user/month"
+  enterprise: "Custom pricing \u2014 Contact Sales"
 };
 async function requireTier(minimumTier) {
   if (process.env["SKILLSMITH_SKIP_LICENSE_CHECK"] === "true") {
@@ -39632,7 +40629,7 @@ function diffSections(oldContent, newContent) {
   return { added, removed, modified };
 }
 async function readInstalledSkillContent(skillName) {
-  const skillPath = join50(getCanonicalInstallPath(), skillName, "SKILL.md");
+  const skillPath = join51(getCanonicalInstallPath(), skillName, "SKILL.md");
   try {
     return await readFile12(skillPath, "utf-8");
   } catch {
@@ -39844,7 +40841,7 @@ import { Command as Command22 } from "commander";
 import * as crypto12 from "node:crypto";
 import * as fs34 from "node:fs";
 import { homedir as homedir28 } from "node:os";
-import { join as join62 } from "node:path";
+import { join as join63 } from "node:path";
 import { Command as Command19 } from "commander";
 import { input as input4, select as select3 } from "@inquirer/prompts";
 
@@ -44423,6 +45420,9 @@ function makeClaudeMdEntry(claudeMdPath, phrase, mtime) {
     identifier: hashClaudeMdLine(claudeMdPath, phrase),
     triggerSurface: [phrase],
     mtime,
+    // CLAUDE.md rules are Claude Code-only (SMI-6077) — no other supported
+    // client reads this file today.
+    client: CANONICAL_CLIENT,
     meta: { description: phrase }
   };
 }
@@ -45067,8 +46067,14 @@ import * as os10 from "node:os";
 import * as fs20 from "node:fs";
 import * as os7 from "node:os";
 import * as path18 from "node:path";
-var DEFAULT_HOME_CLAUDE_DIR = path18.join(os7.homedir(), ".claude");
-var DEFAULT_MANIFEST_PATH3 = path18.join(os7.homedir(), ".skillsmith", "manifest.json");
+var REAL_HOME_DIR = os7.homedir();
+var DEFAULT_HOME_CLAUDE_DIR = path18.join(REAL_HOME_DIR, ".claude");
+var DEFAULT_MANIFEST_PATH3 = path18.join(REAL_HOME_DIR, ".skillsmith", "manifest.json");
+function resolveClientSkillsDir(client, homeDir) {
+  const nativePath = CLIENT_NATIVE_PATHS[client];
+  const relativeToRealHome = path18.relative(REAL_HOME_DIR, nativePath);
+  return path18.join(homeDir, relativeToRealHome);
+}
 async function scanLocalInventory(opts = {}) {
   const startedAt = process.hrtime.bigint();
   const homeDir = opts.homeDir ?? os7.homedir();
@@ -45077,9 +46083,10 @@ async function scanLocalInventory(opts = {}) {
   const warnings = [];
   const entries = [];
   const manifest = loadManifest3(manifestPath);
-  entries.push(...scanSkills(path18.join(claudeDir, "skills"), manifest, warnings));
-  const agentsSkillsDir = opts.homeDir ? path18.join(opts.homeDir, ".agents", "skills") : path18.join(os7.homedir(), ".agents", "skills");
-  entries.push(...scanSkills(agentsSkillsDir, manifest, warnings));
+  for (const client of CLIENT_IDS) {
+    const skillsDir = resolveClientSkillsDir(client, homeDir);
+    entries.push(...scanSkills(skillsDir, manifest, warnings, client));
+  }
   entries.push(...scanCommands(path18.join(claudeDir, "commands"), warnings));
   entries.push(...scanAgents(path18.join(claudeDir, "agents"), warnings));
   const userClaudeMd = path18.join(claudeDir, "CLAUDE.md");
@@ -45099,10 +46106,9 @@ async function scanLocalInventory(opts = {}) {
   });
   const elapsedNs = process.hrtime.bigint() - startedAt;
   const durationMs = Number(elapsedNs) / 1e6;
-  void homeDir;
   return { entries, warnings, durationMs };
 }
-function scanSkills(skillsDir, manifest, warnings) {
+function scanSkills(skillsDir, manifest, warnings, client) {
   if (!fs20.existsSync(skillsDir))
     return [];
   const out = [];
@@ -45144,6 +46150,7 @@ function scanSkills(skillsDir, manifest, warnings) {
       identifier,
       triggerSurface: phrases,
       mtime,
+      client,
       meta: {
         description,
         author: author.author,
@@ -45193,6 +46200,7 @@ function scanMdDir(dir, kind, warnings) {
       identifier,
       triggerSurface: phrases,
       mtime: readMtime(filePath),
+      client: CANONICAL_CLIENT,
       meta: {
         description: triggerLine || void 0
       }
@@ -46811,11 +47819,11 @@ import * as os14 from "node:os";
 
 // ../core/dist/src/audit/exclusions.js
 import { promises as fs30 } from "node:fs";
-import { join as join60 } from "node:path";
+import { join as join61 } from "node:path";
 var EXCLUSIONS_FILE = "audit-exclusions.json";
 var EMPTY_CONFIG = { version: 1, exclusions: [] };
 function getExclusionsPath(opts) {
-  return join60(opts?.configDir ?? getConfigDir(), EXCLUSIONS_FILE);
+  return join61(opts?.configDir ?? getConfigDir(), EXCLUSIONS_FILE);
 }
 async function loadExclusions(opts = {}) {
   const path27 = opts.configPath ?? getExclusionsPath();
@@ -47213,7 +48221,7 @@ function formatTierBadge(tier) {
 function displayLicenseStatus(status) {
   const tierBadge = formatTierBadge(status.tier);
   if (status.tier === "community") {
-    console.error(`License: ${tierBadge} ${source_default.dim("(free tier - 1,000 API calls/month)")}`);
+    console.error(`License: ${tierBadge} ${source_default.dim("(free tier - 100 API calls/month)")}`);
   } else if (status.tier === "individual") {
     const expiresInfo = status.expiresAt ? source_default.green(`(expires: ${status.expiresAt.toISOString().split("T")[0]})`) : "";
     console.error(`License: ${tierBadge} ${expiresInfo}`);
@@ -47277,10 +48285,10 @@ async function requireConfirmationPhrase(expected, prompt) {
   }
 }
 function ledgerPath() {
-  return join62(homedir28(), ".skillsmith", "namespace-overrides.json");
+  return join63(homedir28(), ".skillsmith", "namespace-overrides.json");
 }
 function backupsDir() {
-  return join62(homedir28(), ".skillsmith", "backups");
+  return join63(homedir28(), ".skillsmith", "backups");
 }
 function backupLedgerForReset() {
   const src = ledgerPath();
@@ -47289,7 +48297,7 @@ function backupLedgerForReset() {
   fs34.mkdirSync(dir, { recursive: true, mode: 448 });
   const ts2 = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   const suffix = crypto12.randomBytes(4).toString("hex");
-  const backupFile = join62(dir, `ledger-${ts2}-${suffix}.json`);
+  const backupFile = join63(dir, `ledger-${ts2}-${suffix}.json`);
   fs34.copyFileSync(src, backupFile);
   return backupFile;
 }
@@ -47548,9 +48556,9 @@ function methodCell(skill) {
 function printHumanReport(report, applying) {
   console.log(source_default.bold.blue("\n=== Skillsmith \u2014 Source Recovery ===\n"));
   const hdr = pad("skill", COL_SKILL) + "| " + pad("source", COL_SOURCE) + "| " + pad("confidence", COL_CONF) + "| method";
-  const sep6 = "-".repeat(hdr.length);
+  const sep7 = "-".repeat(hdr.length);
   console.log(hdr);
-  console.log(sep6);
+  console.log(sep7);
   for (const skill of report.skills) {
     const row = pad(skill.skillName, COL_SKILL) + "| " + pad(sourceCell(skill), COL_SOURCE) + "| " + pad(confCell(skill), COL_CONF) + "| " + methodCell(skill);
     console.log(row);
@@ -47703,10 +48711,10 @@ function createAuditSourcesSubcommand() {
 import { Command as Command21 } from "commander";
 
 // src/commands/audit-security.candidates.ts
-var SEVERITY_RANK = { critical: 0, high: 1, medium: 2, low: 3 };
+var SEVERITY_RANK2 = { critical: 0, high: 1, medium: 2, low: 3 };
 function compareCandidates(a, b) {
-  const sa = SEVERITY_RANK[a.finding.severity] ?? 4;
-  const sb = SEVERITY_RANK[b.finding.severity] ?? 4;
+  const sa = SEVERITY_RANK2[a.finding.severity] ?? 4;
+  const sb = SEVERITY_RANK2[b.finding.severity] ?? 4;
   if (sa !== sb) return sa - sb;
   if (a.identifier !== b.identifier) return a.identifier < b.identifier ? -1 : 1;
   const fa = a.finding.filePath ?? "";
@@ -48326,7 +49334,7 @@ import { Command as Command23 } from "commander";
 import { input as input6, confirm as confirm6, select as select4 } from "@inquirer/prompts";
 import ora13 from "ora";
 import { mkdir as mkdir17, writeFile as writeFile15, stat as stat12 } from "fs/promises";
-import { join as join63 } from "path";
+import { join as join64 } from "path";
 var logger29 = getCliLogger();
 var VALID_TYPES = ["basic", "intermediate", "advanced"];
 var VALID_BEHAVIORS = ["autonomous", "guided", "interactive", "configurable"];
@@ -48462,7 +49470,7 @@ async function createSkill(name, options = {}) {
     default: false
   });
   const outputDir = options.output ?? getCanonicalInstallPath();
-  const skillDir = join63(outputDir, skillName);
+  const skillDir = join64(outputDir, skillName);
   let exists = false;
   try {
     await stat12(skillDir);
@@ -48536,16 +49544,16 @@ Thumbs.db
   const spinner = ora13("Scaffolding skill...").start();
   try {
     await mkdir17(skillDir, { recursive: true });
-    await mkdir17(join63(skillDir, "resources"), { recursive: true });
+    await mkdir17(join64(skillDir, "resources"), { recursive: true });
     if (includeScripts) {
-      await mkdir17(join63(skillDir, "scripts"), { recursive: true });
+      await mkdir17(join64(skillDir, "scripts"), { recursive: true });
     }
-    await writeFile15(join63(skillDir, "SKILL.md"), skillMdContent, "utf-8");
-    await writeFile15(join63(skillDir, "README.md"), readmeContent, "utf-8");
-    await writeFile15(join63(skillDir, "CHANGELOG.md"), changelogContent, "utf-8");
-    await writeFile15(join63(skillDir, ".gitignore"), gitignoreContent, "utf-8");
+    await writeFile15(join64(skillDir, "SKILL.md"), skillMdContent, "utf-8");
+    await writeFile15(join64(skillDir, "README.md"), readmeContent, "utf-8");
+    await writeFile15(join64(skillDir, "CHANGELOG.md"), changelogContent, "utf-8");
+    await writeFile15(join64(skillDir, ".gitignore"), gitignoreContent, "utf-8");
     if (includeScripts) {
-      await writeFile15(join63(skillDir, "scripts", "example.js"), scriptContent, "utf-8");
+      await writeFile15(join64(skillDir, "scripts", "example.js"), scriptContent, "utf-8");
     }
     spinner.succeed(`Skill scaffolded at ${skillDir}`);
   } catch (error46) {
@@ -48924,7 +49932,7 @@ import { promises as fs36 } from "node:fs";
 // src/commands/import-local.helpers.ts
 import { createHash as createHash19 } from "node:crypto";
 import { promises as fs35 } from "node:fs";
-import { join as join64, resolve as resolve17, dirname as dirname29, basename as basename10, sep as sep5, relative as relative7 } from "node:path";
+import { join as join65, resolve as resolve17, dirname as dirname29, basename as basename10, sep as sep6, relative as relative9 } from "node:path";
 import matter from "gray-matter";
 var SKILL_FILENAME = "SKILL.md";
 var MAX_DEPTH = 8;
@@ -48945,7 +49953,7 @@ async function walkSkillFiles(rootDir) {
       return;
     }
     for (const entry of entries) {
-      const entryPath = join64(dir, entry.name);
+      const entryPath = join65(dir, entry.name);
       if (entry.isSymbolicLink()) {
         let realPath;
         try {
@@ -48953,8 +49961,8 @@ async function walkSkillFiles(rootDir) {
         } catch {
           continue;
         }
-        const rel = relative7(canonicalRoot, realPath);
-        if (rel.startsWith("..") || rel === ".." || rel.startsWith(`..${sep5}`)) {
+        const rel = relative9(canonicalRoot, realPath);
+        if (rel.startsWith("..") || rel === ".." || rel.startsWith(`..${sep6}`)) {
           skipped.push({ path: entryPath, reason: "symlink-escapes-root" });
           continue;
         }
@@ -49254,7 +50262,7 @@ function printHumanSummary(result) {
 import * as crypto13 from "node:crypto";
 import * as fs37 from "node:fs";
 import { homedir as homedir29 } from "node:os";
-import { join as join65, dirname as dirname30 } from "node:path";
+import { join as join66, dirname as dirname30 } from "node:path";
 import { Command as Command27 } from "commander";
 var logger33 = getCliLogger();
 var CONFIG_DIR3 = ".skillsmith";
@@ -49278,7 +50286,7 @@ function isSupportedKey(key) {
   return SUPPORTED_KEYS.includes(key);
 }
 function configPath() {
-  return join65(homedir29(), CONFIG_DIR3, CONFIG_FILE3);
+  return join66(homedir29(), CONFIG_DIR3, CONFIG_FILE3);
 }
 function readConfigFile2() {
   const path27 = configPath();
@@ -49395,15 +50403,15 @@ function createConfigCommand2() {
 import { Command as Command28 } from "commander";
 
 // src/commands/telemetry.action.ts
-import { existsSync as existsSync28, copyFileSync as copyFileSync2, chmodSync as chmodSync9, mkdirSync as mkdirSync14 } from "node:fs";
+import { existsSync as existsSync29, copyFileSync as copyFileSync2, chmodSync as chmodSync9, mkdirSync as mkdirSync14 } from "node:fs";
 import { homedir as homedir31 } from "node:os";
-import { join as join67, dirname as dirname32 } from "node:path";
+import { join as join68, dirname as dirname32 } from "node:path";
 import { readdirSync as readdirSync4, unlinkSync as unlinkSync5, statSync as statSync6 } from "node:fs";
 
 // src/commands/telemetry.helpers.ts
 import * as crypto14 from "node:crypto";
 import * as fs38 from "node:fs";
-import { join as join66, dirname as dirname31 } from "node:path";
+import { join as join67, dirname as dirname31 } from "node:path";
 import { homedir as homedir30 } from "node:os";
 var TelemetryHookError = class extends Error {
   constructor(code, message) {
@@ -49415,9 +50423,9 @@ var TelemetryHookError = class extends Error {
 };
 function resolveSettingsPath(scope) {
   if (scope === "user") {
-    return join66(homedir30(), ".claude", "settings.json");
+    return join67(homedir30(), ".claude", "settings.json");
   }
-  return join66(process.cwd(), ".claude", "settings.json");
+  return join67(process.cwd(), ".claude", "settings.json");
 }
 function loadClaudeSettings(scope) {
   const path27 = resolveSettingsPath(scope);
@@ -49509,10 +50517,10 @@ var PRIVACY_URL = "https://skillsmith.app/privacy#telemetry";
 var DEFAULT_ENDPOINT = "https://vrcnzpmndtroqxxoqkzy.supabase.co/functions/v1/events";
 var ORPHAN_TTL_MS = 60 * 60 * 1e3;
 function hookScriptPath() {
-  return join67(homedir31(), ".skillsmith", "hooks", "skill-telemetry.sh");
+  return join68(homedir31(), ".skillsmith", "hooks", "skill-telemetry.sh");
 }
 function runDir() {
-  return join67(homedir31(), ".skillsmith", "run");
+  return join68(homedir31(), ".skillsmith", "run");
 }
 function idTail(id) {
   if (!id) return "(none)";
@@ -49521,11 +50529,11 @@ function idTail(id) {
 function gcOrphanRunFiles() {
   try {
     const dir = runDir();
-    if (!existsSync28(dir)) return;
+    if (!existsSync29(dir)) return;
     const now = Date.now();
     for (const f of readdirSync4(dir)) {
       if (!f.startsWith("skill-")) continue;
-      const fp = join67(dir, f);
+      const fp = join68(dir, f);
       try {
         const st = statSync6(fp);
         if (now - st.mtimeMs > ORPHAN_TTL_MS) unlinkSync5(fp);
@@ -49625,8 +50633,8 @@ async function runStatus() {
   }
 }
 async function runInstallHook(options) {
-  const templateSrc = join67(packageRoot(), "templates", "skill-telemetry.sh");
-  if (!existsSync28(templateSrc)) {
+  const templateSrc = join68(packageRoot(), "templates", "skill-telemetry.sh");
+  if (!existsSync29(templateSrc)) {
     throw new Error(
       "skill-telemetry.sh template not found. Ensure the CLI package is fully built: npm run build"
     );
@@ -49669,7 +50677,7 @@ async function runUninstallHook(options) {
   writeClaudeSettings(scope, updated);
   try {
     const scriptPath = hookScriptPath();
-    if (existsSync28(scriptPath)) unlinkSync5(scriptPath);
+    if (existsSync29(scriptPath)) unlinkSync5(scriptPath);
   } catch {
   }
   const scopeLabel = scope === "user" ? "~/.claude/settings.json" : "./.claude/settings.json";
@@ -49880,7 +50888,7 @@ async function runStatus2(opts) {
   const localCount = countByHarness.get("local") ?? 0;
   if (localCount > 0) {
     console.log(
-      `  Local skills:   ${source_default.dim(`${localCount} skill${localCount === 1 ? "" : "s"} in ./.claude/skills (repo-local \u2014 not synced to your account)`)}`
+      `  Local skills:   ${source_default.dim(`${localCount} skill${localCount === 1 ? "" : "s"} in ${getLocalSkillsDirDisplay()} (repo-local \u2014 not synced to your account)`)}`
     );
     if (opts?.verbose) {
       for (const s of allSkills.filter((e) => e.harness === "local")) {
@@ -50088,14 +51096,14 @@ function createAgentCommand() {
 }
 
 // src/commands/diagnose.ts
-import { mkdirSync as mkdirSync15, readFileSync as readFileSync26, writeFileSync as writeFileSync16 } from "node:fs";
+import { mkdirSync as mkdirSync15, readFileSync as readFileSync27, writeFileSync as writeFileSync17 } from "node:fs";
 import { basename as basename11, dirname as dirname33, resolve as resolve19 } from "node:path";
 import { Command as Command31 } from "commander";
 
 // src/commands/log-records.helpers.ts
-import { existsSync as existsSync29, readFileSync as readFileSync25, readdirSync as readdirSync5, statSync as statSync7 } from "node:fs";
+import { existsSync as existsSync30, readFileSync as readFileSync26, readdirSync as readdirSync5, statSync as statSync7 } from "node:fs";
 import { homedir as homedir32 } from "node:os";
-import { join as join68 } from "node:path";
+import { join as join69 } from "node:path";
 var LOG_FILE_PATTERN = /^skillsmith-[a-z]+-\d{4}-\d{2}-\d{2}\.jsonl(\.\d+)?$/;
 var LOG_LEVEL_ORDER = {
   debug: 0,
@@ -50108,12 +51116,12 @@ function isLogLevel(value) {
   return VALID_LEVELS.has(value);
 }
 function resolveLogDir() {
-  return process.env["SKILLSMITH_LOG_DIR"] || join68(homedir32(), ".skillsmith", "logs");
+  return process.env["SKILLSMITH_LOG_DIR"] || join69(homedir32(), ".skillsmith", "logs");
 }
 function listLogFiles(dir) {
-  if (!existsSync29(dir)) return [];
+  if (!existsSync30(dir)) return [];
   try {
-    return readdirSync5(dir).filter((name) => LOG_FILE_PATTERN.test(name)).sort().map((name) => join68(dir, name));
+    return readdirSync5(dir).filter((name) => LOG_FILE_PATTERN.test(name)).sort().map((name) => join69(dir, name));
   } catch {
     return [];
   }
@@ -50121,7 +51129,7 @@ function listLogFiles(dir) {
 function readLogRecords(filePath) {
   let content;
   try {
-    content = readFileSync25(filePath, "utf8");
+    content = readFileSync26(filePath, "utf8");
   } catch {
     return [];
   }
@@ -50227,7 +51235,7 @@ function buildBundleContent(summary, files) {
       parts.push("");
       parts.push(`===== ${basename11(file2)} (${fileSizeBytes(file2)} bytes) =====`);
       try {
-        parts.push(readFileSync26(file2, "utf8"));
+        parts.push(readFileSync27(file2, "utf8"));
       } catch (error46) {
         parts.push(`[failed to read: ${sanitizeError(error46)}]`);
       }
@@ -50240,7 +51248,7 @@ function writeBundle(bundleOption, summary, files) {
   const targetPath = resolve19(rawPath);
   const content = buildBundleContent(summary, files);
   mkdirSync15(dirname33(targetPath), { recursive: true });
-  writeFileSync16(targetPath, content, "utf8");
+  writeFileSync17(targetPath, content, "utf8");
   return targetPath;
 }
 async function runDiagnose(options) {
@@ -50298,8 +51306,8 @@ function createDiagnoseCommand() {
 }
 
 // src/commands/logs.ts
-import { existsSync as existsSync30, readFileSync as readFileSync27, statSync as statSync8 } from "node:fs";
-import { join as join69 } from "node:path";
+import { existsSync as existsSync31, readFileSync as readFileSync28, statSync as statSync8 } from "node:fs";
+import { join as join70 } from "node:path";
 import { Command as Command32 } from "commander";
 var logger38 = getCliLogger();
 var TAIL_SURFACES = ["cli", "mcp", "vscode", "doc-retrieval"];
@@ -50308,7 +51316,7 @@ function todayDateString2() {
 }
 function todaysFilePaths(dir) {
   const date5 = todayDateString2();
-  return TAIL_SURFACES.map((surface) => join69(dir, `skillsmith-${surface}-${date5}.jsonl`));
+  return TAIL_SURFACES.map((surface) => join70(dir, `skillsmith-${surface}-${date5}.jsonl`));
 }
 function resolveLevel(raw) {
   if (raw === void 0) return void 0;
@@ -50341,7 +51349,7 @@ async function startTail(dir, level, opts = {}) {
   const offsets = /* @__PURE__ */ new Map();
   let printedAny = false;
   for (const path27 of paths) {
-    if (!existsSync30(path27)) {
+    if (!existsSync31(path27)) {
       offsets.set(path27, 0);
       continue;
     }
@@ -50380,7 +51388,7 @@ async function startTail(dir, level, opts = {}) {
     }
     let content;
     try {
-      content = readFileSync27(path27).subarray(previousOffset).toString("utf8");
+      content = readFileSync28(path27).subarray(previousOffset).toString("utf8");
     } catch {
       return;
     }
@@ -50457,12 +51465,12 @@ function applyRootQuietOption(rootQuiet) {
 }
 
 // src/utils/node-version.ts
-import { readFileSync as readFileSync28 } from "fs";
-import { join as join70 } from "path";
+import { readFileSync as readFileSync29 } from "fs";
+import { join as join71 } from "path";
 function loadMinNodeVersion() {
   try {
-    const packageJsonPath2 = join70(packageRoot(), "package.json");
-    const packageJson2 = JSON.parse(readFileSync28(packageJsonPath2, "utf-8"));
+    const packageJsonPath2 = join71(packageRoot(), "package.json");
+    const packageJson2 = JSON.parse(readFileSync29(packageJsonPath2, "utf-8"));
     const engineConstraint = packageJson2.engines?.node ?? ">=22.22.0";
     return engineConstraint.replace(/[>=<^~\s]/g, "");
   } catch {
@@ -50533,21 +51541,21 @@ function checkNodeVersion() {
 }
 
 // src/index.ts
-import { readFileSync as readFileSync29 } from "fs";
-import { join as join71 } from "path";
+import { readFileSync as readFileSync30 } from "fs";
+import { join as join72 } from "path";
 var logger39 = getCliLogger();
 var versionError = checkNodeVersion();
 if (versionError) {
   logger39.error(versionError);
   process.exit(1);
 }
-var packageJsonPath = join71(packageRoot(), "package.json");
-var packageJson = JSON.parse(readFileSync29(packageJsonPath, "utf-8"));
+var packageJsonPath = join72(packageRoot(), "package.json");
+var packageJson = JSON.parse(readFileSync30(packageJsonPath, "utf-8"));
 var CLI_VERSION = packageJson.version;
 var program = new Command33();
 var commandName = process.argv[1]?.endsWith("sklx") ? "sklx" : "skillsmith";
 program.name(commandName).description(
-  "Publish versioned agent skills to a team-scoped registry, catch drift across installs, and deprecate what's gone stale. (alias: sklx)"
+  "A registry for sharing, scanning, and tracking agent skills across teams. (alias: sklx)"
 ).version(CLI_VERSION).option(
   "--quiet",
   "Suppress advisory/progress output across all commands (sets SKILLSMITH_QUIET)"