@gendigital/sage-opencode 0.13.0 → 0.15.0

package/dist/mcp-server.cjs

@@ -46,6 +46,39 @@ function getProcEnv() {
 function getHomeDir() {
   return getProcEnv().HOME || (0, import_node_os.homedir)();
 }
+async function renameWithRetry(from, to, attempts = 5) {
+  if (process.platform !== "win32") {
+    await fsPromises.rename(from, to);
+    return;
+  }
+  for (let i = 0; i < attempts; i++) {
+    try {
+      await fsPromises.rename(from, to);
+      return;
+    } catch (err) {
+      const code = err.code;
+      const transient = code === "EPERM" || code === "EACCES" || code === "EBUSY";
+      if (!transient || i === attempts - 1)
+        throw err;
+      await new Promise((resolve2) => setTimeout(resolve2, 10 * 2 ** i));
+    }
+  }
+}
+async function atomicWriteJson(path2, data) {
+  await fsPromises.mkdir((0, import_node_path.dirname)(path2), { recursive: true });
+  const tmp = `${path2}.${(0, import_node_crypto.randomBytes)(6).toString("hex")}.tmp`;
+  try {
+    await fsPromises.writeFile(tmp, `${JSON.stringify(data, null, 2)}
+`, { mode: 384 });
+    await renameWithRetry(tmp, path2);
+  } catch (err) {
+    try {
+      await fsPromises.unlink(tmp);
+    } catch {
+    }
+    throw err;
+  }
+}
 async function removeStaleFileLock(lockPath, staleAgeMs) {
   try {
     const s = await fsPromises.stat(lockPath);
@@ -86,13 +119,15 @@ async function withFileLock(filePath, callback) {
     await release();
   }
 }
-var fs, fsPromises, import_node_os, import_promises, name1, name2;
+var import_node_crypto, fs, fsPromises, import_node_os, import_node_path, import_promises, name1, name2;
 var init_file_utils = __esm({
   "../core/dist/file-utils.js"() {
     "use strict";
+    import_node_crypto = require("node:crypto");
     fs = __toESM(require("node:fs"), 1);
     fsPromises = __toESM(require("node:fs/promises"), 1);
     import_node_os = require("node:os");
+    import_node_path = require("node:path");
     import_promises = require("node:timers/promises");
     name1 = "read";
     name2 = "File";
@@ -4206,7 +4241,7 @@ var init_zod = __esm({
 });
 
 // ../core/dist/types.js
-var nullLogger, ArtifactTypeSchema, ArtifactSchema, VerdictSeveritySchema, ThreatSchema, DecisionSchema, SensitivitySchema, UrlCheckConfigSchema, CacheConfigSchema, LoggingConfigSchema, OperationalLogLevelSchema, OperationalLoggingConfigSchema, FileCheckConfigSchema, PackageCheckConfigSchema, AmsiCheckConfigSchema, SkillCheckConfigSchema, PiCheckConfigSchema, ExceptionDecisionSchema, ExceptionMatchSchema, ExceptionRuleSchema, ExceptionsFileSchema, ExceptionsConfigSchema, ConfigSchema, HookTypeSchema;
+var nullLogger, ArtifactTypeSchema, ArtifactSchema, VerdictSeveritySchema, ThreatSchema, DecisionSchema, SensitivitySchema, UrlCheckConfigSchema, CacheConfigSchema, LoggingConfigSchema, OperationalLogLevelSchema, OperationalLoggingConfigSchema, FileCheckConfigSchema, PackageCheckConfigSchema, AmsiCheckConfigSchema, SkillCheckConfigSchema, DEFAULT_PI_MEDIUM_RISK_THRESHOLD, PiCheckConfigSchema, ExceptionDecisionSchema, ExceptionMatchSchema, ExceptionRuleSchema, ExceptionsFileSchema, ExceptionsConfigSchema, ConfigSchema, HookTypeSchema;
 var init_types2 = __esm({
   "../core/dist/types.js"() {
     "use strict";
@@ -4295,6 +4330,7 @@ var init_types2 = __esm({
        */
       upload_enabled: external_exports.boolean().default(true)
     });
+    DEFAULT_PI_MEDIUM_RISK_THRESHOLD = 0.5;
     PiCheckConfigSchema = external_exports.object({
       enabled: external_exports.boolean().default(false),
       max_content_length: external_exports.number().default(16384),
@@ -4346,38 +4382,48 @@ var init_types2 = __esm({
 });
 
 // ../core/dist/config.js
+function skillCacheTtlMs(config2) {
+  return Math.max(1, config2.skill_check.cache_ttl_days) * MS_PER_DAY;
+}
+function isFreshTimestamp(ts, ttlMs, now = Date.now()) {
+  if (Number.isNaN(ts))
+    return false;
+  if (ts - now > CLOCK_SKEW_TOLERANCE_MS)
+    return false;
+  return now - ts < ttlMs;
+}
 function resolvedSageDir() {
   return resolvePath(SAGE_DIR);
 }
 function defaultConfigPath() {
-  return (0, import_node_path.join)(resolvedSageDir(), "config.json");
+  return (0, import_node_path2.join)(resolvedSageDir(), "config.json");
 }
 function defaultCachePath() {
-  return (0, import_node_path.join)(resolvedSageDir(), "cache.json");
+  return (0, import_node_path2.join)(resolvedSageDir(), "cache.json");
 }
 function defaultExceptionsPath() {
-  return (0, import_node_path.join)(resolvedSageDir(), "exceptions.json");
+  return (0, import_node_path2.join)(resolvedSageDir(), "exceptions.json");
 }
 function defaultAuditPath() {
-  return (0, import_node_path.join)(resolvedSageDir(), "audit.jsonl");
+  return (0, import_node_path2.join)(resolvedSageDir(), "audit.jsonl");
 }
 function defaultOperationalLogPath() {
-  return (0, import_node_path.join)(resolvedSageDir(), "operational.jsonl");
+  return (0, import_node_path2.join)(resolvedSageDir(), "operational.jsonl");
 }
 function resolvePath(pathStr) {
   if (pathStr.startsWith("~/") || pathStr === "~") {
     const home = getHomeDir();
-    return (0, import_node_path.join)(home, pathStr.slice(1));
+    return (0, import_node_path2.join)(home, pathStr.slice(1));
   }
   return pathStr;
 }
 function isWithinDirectory(baseDir, targetPath) {
-  const rel = (0, import_node_path.relative)(baseDir, targetPath);
+  const rel = (0, import_node_path2.relative)(baseDir, targetPath);
   if (rel === "")
     return true;
-  if ((0, import_node_path.isAbsolute)(rel))
+  if ((0, import_node_path2.isAbsolute)(rel))
     return false;
-  return rel !== ".." && !rel.startsWith(`..${import_node_path.sep}`);
+  return rel !== ".." && !rel.startsWith(`..${import_node_path2.sep}`);
 }
 function normalizeStateFilePath(configuredPath, fallbackPath, field, logger2) {
   const sageDir = resolvedSageDir();
@@ -4390,7 +4436,7 @@ function normalizeStateFilePath(configuredPath, fallbackPath, field, logger2) {
     return fallbackPath;
   }
   const expanded = resolvePath(trimmed);
-  const resolved = (0, import_node_path.isAbsolute)(expanded) ? (0, import_node_path.resolve)(expanded) : (0, import_node_path.resolve)(sageDir, expanded);
+  const resolved = (0, import_node_path2.isAbsolute)(expanded) ? (0, import_node_path2.resolve)(expanded) : (0, import_node_path2.resolve)(sageDir, expanded);
   if (isWithinDirectory(sageDir, resolved)) {
     if (resolved === sageDir) {
       logger2.warn(`Config ${field}.path must point to a file; using default`, {
@@ -4489,11 +4535,11 @@ async function loadConfig(configPath, logger2 = nullLogger) {
     return defaultConfig(logger2);
   }
 }
-var import_node_path, SAGE_DIR, MS_PER_DAY, CLOCK_SKEW_TOLERANCE_MS, BRAND_KEY_RE;
+var import_node_path2, SAGE_DIR, MS_PER_DAY, CLOCK_SKEW_TOLERANCE_MS, BRAND_KEY_RE;
 var init_config = __esm({
   "../core/dist/config.js"() {
     "use strict";
-    import_node_path = require("node:path");
+    import_node_path2 = require("node:path");
     init_file_utils();
     init_types2();
     SAGE_DIR = "~/.sage";
@@ -20548,12 +20594,57 @@ function safeTruncate(value, maxLen) {
   return value.slice(0, cutIndex);
 }
 
+// ../core/dist/model-storage.js
+init_config();
+
+// ../core/dist/detection-names.js
+init_types2();
+var REPORTING_ENGINE_SHORTHANDS = {
+  package: "sgpk",
+  amsi: "sgam",
+  heuristics: "sghe",
+  ml: "sgml",
+  skill: "skan"
+};
+var REPORTING_DETECTION_SUFFIX = "sage";
+function formatReportingDetectionName(canonicalName, engine, optionalData = "") {
+  const engineMetadata = optionalData ? `${REPORTING_ENGINE_SHORTHANDS[engine]}:${optionalData}` : REPORTING_ENGINE_SHORTHANDS[engine];
+  return `${canonicalName}|${engineMetadata}|${REPORTING_DETECTION_SUFFIX}`;
+}
+var SKILL_DETECTION_NAMES = {
+  HIGH: "Other:SageSuspiciousSkill-A [Susp]",
+  CRITICAL: "Other:SageMaliciousSkill-A [Trj]"
+};
+function skillDetectionName(verdict) {
+  return SKILL_DETECTION_NAMES[verdict.toUpperCase()];
+}
+function isSkillId(value) {
+  return /^[0-9a-f]{64}$/i.test(value);
+}
+function skillReportingDetectionName(verdict, skillId) {
+  const canonicalName = skillDetectionName(verdict);
+  return canonicalName && isSkillId(skillId) ? formatReportingDetectionName(canonicalName, "skill", skillId.toLowerCase()) : void 0;
+}
+function buildSkillCheckSignal(skillId, analyzerVerdict, jobId) {
+  const normalizedSkillId = skillId.toLowerCase();
+  const normalizedVerdict = analyzerVerdict.toUpperCase();
+  const detectionName = skillReportingDetectionName(normalizedVerdict, normalizedSkillId);
+  if (!detectionName)
+    return void 0;
+  return {
+    detection_name: detectionName,
+    skill_id: normalizedSkillId,
+    ...jobId ? { job_id: jobId } : {},
+    analyzer_verdict: normalizedVerdict
+  };
+}
+
 // ../core/dist/audit-log.js
 init_file_utils();
 
 // ../core/dist/jsonl-log-writer.js
 var import_promises2 = require("node:fs/promises");
-var import_node_path2 = require("node:path");
+var import_node_path3 = require("node:path");
 init_config();
 init_file_utils();
 var writeQueues = /* @__PURE__ */ new Map();
@@ -20590,7 +20681,7 @@ async function rotateIfNeeded(filePath, maxBytes, maxFiles) {
   });
 }
 async function appendJsonlEntryNow(path2, config2, entry) {
-  await (0, import_promises2.mkdir)((0, import_node_path2.dirname)(path2), { recursive: true });
+  await (0, import_promises2.mkdir)((0, import_node_path3.dirname)(path2), { recursive: true });
   await rotateIfNeeded(path2, config2.max_bytes, config2.max_files);
   await (0, import_promises2.appendFile)(path2, `${JSON.stringify(entry)}
 `);
@@ -20784,15 +20875,15 @@ init_types2();
 init_types2();
 
 // ../core/dist/version.js
-var import_node_path3 = require("node:path");
+var import_node_path4 = require("node:path");
 var import_node_url = require("node:url");
 init_file_utils();
 var import_meta = {};
 function resolveVersion() {
   if (true)
-    return "0.13.0";
+    return "0.15.0";
   try {
-    const pkgPath = (0, import_node_path3.join)((0, import_node_path3.dirname)((0, import_node_url.fileURLToPath)(import_meta.url)), "..", "package.json");
+    const pkgPath = (0, import_node_path4.join)((0, import_node_path4.dirname)((0, import_node_url.fileURLToPath)(import_meta.url)), "..", "package.json");
     const pkg = JSON.parse(getFileContentSync(pkgPath));
     if (typeof pkg.version === "string")
       return pkg.version;
@@ -20802,9 +20893,6 @@ function resolveVersion() {
 }
 var VERSION = resolveVersion();
 
-// ../core/dist/model-storage.js
-init_config();
-
 // ../core/dist/clients/model-downloader.js
 init_types2();
 var STALE_LOCK_MS = 60 * 60 * 1e3;
@@ -20913,7 +21001,7 @@ init_types2();
 // ../core/dist/extended-info.js
 var import_promises3 = require("node:fs/promises");
 var import_node_os2 = require("node:os");
-var import_node_path4 = require("node:path");
+var import_node_path5 = require("node:path");
 init_file_utils();
 init_types2();
 var EXTENDED_INFO_FILE_MAX_BYTES = 1024;
@@ -20979,8 +21067,8 @@ function sanitizeDocument(parsed, logger2) {
   return out;
 }
 async function loadExtendedInfo(sageDirPath, logger2 = nullLogger) {
-  const sageDir = sageDirPath ?? (0, import_node_path4.join)((0, import_node_os2.homedir)(), ".sage");
-  const filePath = (0, import_node_path4.join)(sageDir, EXTENDED_INFO_FILENAME);
+  const sageDir = sageDirPath ?? (0, import_node_path5.join)((0, import_node_os2.homedir)(), ".sage");
+  const filePath = (0, import_node_path5.join)(sageDir, EXTENDED_INFO_FILENAME);
   const cached2 = cache.get(filePath);
   if (cached2)
     return cached2.value;
@@ -21078,14 +21166,14 @@ function mergeExtendedInfo(envelope, extendedInfo) {
 }
 
 // ../core/dist/installation-id.js
-var import_node_crypto = require("node:crypto");
+var import_node_crypto2 = require("node:crypto");
 var import_promises4 = require("node:fs/promises");
-var import_node_path5 = require("node:path");
+var import_node_path6 = require("node:path");
 init_config();
 init_file_utils();
 async function getInstallationId(sageDirPath) {
   const sageDir = sageDirPath ?? resolvePath("~/.sage");
-  const idPath = (0, import_node_path5.join)(sageDir, "installation-id");
+  const idPath = (0, import_node_path6.join)(sageDir, "installation-id");
   let fileExists = false;
   try {
     const existing = await getFileContent(idPath, "utf-8");
@@ -21096,7 +21184,7 @@ async function getInstallationId(sageDirPath) {
   } catch {
   }
   try {
-    const id = (0, import_node_crypto.randomUUID)();
+    const id = (0, import_node_crypto2.randomUUID)();
     await (0, import_promises4.mkdir)(sageDir, { recursive: true, mode: 448 });
     await (0, import_promises4.writeFile)(idPath, id, { encoding: "utf-8", mode: 384, flag: fileExists ? "w" : "wx" });
     return id;
@@ -21128,6 +21216,12 @@ init_types2();
 // ../core/dist/evaluator.js
 init_config();
 
+// ../core/dist/extractors.js
+var MAX_CONTENT_SIZE = 64 * 1024;
+
+// ../core/dist/deobfuscate.js
+var REPLACEMENT_CHAR = String.fromCharCode(65533);
+
 // ../core/dist/exceptions.js
 init_config();
 init_file_utils();
@@ -21140,9 +21234,6 @@ init_types2();
 // ../core/dist/exceptions.js
 init_types2();
 
-// ../core/dist/extractors.js
-var MAX_CONTENT_SIZE = 64 * 1024;
-
 // ../core/dist/package-checker.js
 init_types2();
 
@@ -21150,17 +21241,43 @@ init_types2();
 init_config();
 init_file_utils();
 
+// ../core/dist/submit-limits.js
+init_config();
+init_file_utils();
+init_types2();
+var SUBMIT_WINDOW_MS = 24 * 60 * 60 * 1e3;
+
 // ../core/dist/threat-loader.js
 var import_yaml2 = __toESM(require_dist(), 1);
+init_config();
 init_file_utils();
 init_types2();
 
 // ../core/dist/evaluator.js
 init_types2();
+function hasReportableDetectionSignals(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return false;
+  const signals = value;
+  const hasEntries = (key) => {
+    const entries = signals[key];
+    return Array.isArray(entries) && entries.length > 0;
+  };
+  return Boolean(hasEntries("heuristics") || hasEntries("url_checks") || hasEntries("file_checks") || hasEntries("package_checks") || hasEntries("amsi_checks") || Array.isArray(signals.pi_checks) && signals.pi_checks.some((result) => {
+    if (!result || typeof result !== "object" || Array.isArray(result))
+      return false;
+    const risk = result.risk;
+    return typeof risk === "number" && Number.isFinite(risk) && risk >= DEFAULT_PI_MEDIUM_RISK_THRESHOLD;
+  }));
+}
 
 // ../core/dist/index.js
 init_file_utils();
 
+// ../core/dist/format.js
+var FP_REPORT_TOOL_NAME = "sage_report_false_positive";
+var SESSION_START_FP_HINT = `If this is a false positive, ask your agent to report it with the ${FP_REPORT_TOOL_NAME} MCP tool.`;
+
 // ../core/dist/guard.js
 init_config();
 init_types2();
@@ -21311,11 +21428,11 @@ function createOperationalLogger(config2, runtime) {
 }
 
 // ../core/dist/plugin-scan-cache.js
-var import_node_path6 = require("node:path");
+var import_node_path7 = require("node:path");
 init_config();
 init_file_utils();
 init_types2();
-var DEFAULT_CACHE_PATH = (0, import_node_path6.join)(getHomeDir(), ".sage", "plugin_scan_cache.json");
+var DEFAULT_CACHE_PATH = (0, import_node_path7.join)(getHomeDir(), ".sage", "plugin_scan_cache.json");
 
 // ../core/dist/plugin-scanner.js
 init_config();
@@ -21331,9 +21448,119 @@ init_types2();
 var PENDING_TTL_MS = 60 * 60 * 1e3;
 
 // ../core/dist/skill-verdict-cache.js
+var import_node_path8 = require("node:path");
 init_config();
 init_file_utils();
 init_types2();
+var SCHEMA_VERSION = 1;
+var DEFAULT_VERDICT_TTL_MS = MS_PER_DAY;
+function parseSources(raw) {
+  if (!Array.isArray(raw))
+    return void 0;
+  const sources = [];
+  for (const item of raw) {
+    if (!item || typeof item !== "object")
+      continue;
+    const entry = item;
+    const source = {
+      agentRuntime: typeof entry.agent_runtime === "string" ? entry.agent_runtime : void 0,
+      containerKey: typeof entry.container_key === "string" ? entry.container_key : void 0
+    };
+    if (source.agentRuntime || source.containerKey)
+      sources.push(source);
+  }
+  return sources.length > 0 ? sources : void 0;
+}
+function defaultCachePath2() {
+  return (0, import_node_path8.join)(resolvePath(SAGE_DIR), "skill_verdict_cache.json");
+}
+async function loadSkillVerdictCacheInternal(cachePath, ttlMs, logger2, pruneOnLoad) {
+  let raw;
+  try {
+    raw = await getFileContent(cachePath);
+  } catch {
+    return { entries: {} };
+  }
+  try {
+    const data = JSON.parse(raw);
+    const rawEntries = data.entries ?? {};
+    const now = Date.now();
+    const entries = {};
+    let pruned = 0;
+    for (const [skillId, entry] of Object.entries(rawEntries)) {
+      const analyzedAt = entry.analyzed_at;
+      if (!analyzedAt)
+        continue;
+      const ts = Date.parse(analyzedAt);
+      if (!isFreshTimestamp(ts, ttlMs, now)) {
+        pruned++;
+        continue;
+      }
+      entries[skillId] = {
+        entryId: typeof entry.entry_id === "string" ? entry.entry_id : void 0,
+        jobId: typeof entry.job_id === "string" ? entry.job_id : void 0,
+        verdict: typeof entry.verdict === "string" ? entry.verdict : void 0,
+        summary: typeof entry.summary === "string" ? entry.summary : void 0,
+        skillName: typeof entry.skill_name === "string" ? entry.skill_name : void 0,
+        sources: parseSources(entry.sources),
+        analyzedAt
+      };
+    }
+    const cache2 = { entries };
+    if (pruneOnLoad && pruned > 0) {
+      logger2.debug(`Pruned ${pruned} stale verdict(s) from cache`, { cachePath });
+      await saveSkillVerdictCache(cache2, cachePath, logger2);
+    }
+    return cache2;
+  } catch (e) {
+    logger2.warn(`Failed to load verdict cache from ${cachePath}`, { error: String(e) });
+    return { entries: {} };
+  }
+}
+async function loadSkillVerdictCacheReadOnly(cachePath = defaultCachePath2(), ttlMs = DEFAULT_VERDICT_TTL_MS, logger2 = nullLogger) {
+  return loadSkillVerdictCacheInternal(cachePath, ttlMs, logger2, false);
+}
+async function saveSkillVerdictCache(cache2, cachePath = defaultCachePath2(), logger2 = nullLogger) {
+  try {
+    const data = {
+      schema_version: SCHEMA_VERSION,
+      entries: Object.fromEntries(Object.entries(cache2.entries).map(([skillId, v]) => [
+        skillId,
+        {
+          entry_id: v.entryId,
+          job_id: v.jobId,
+          verdict: v.verdict,
+          summary: v.summary,
+          skill_name: v.skillName,
+          sources: v.sources?.map((s) => ({
+            agent_runtime: s.agentRuntime,
+            container_key: s.containerKey
+          })),
+          analyzed_at: v.analyzedAt
+        }
+      ]))
+    };
+    await atomicWriteJson(cachePath, data);
+    return true;
+  } catch (e) {
+    logger2.warn(`Failed to save verdict cache to ${cachePath}`, { error: String(e) });
+    return false;
+  }
+}
+
+// ../core/dist/skill-verdict-record.js
+var import_node_crypto3 = require("node:crypto");
+var SKILL_ENTRY_ID_NAMESPACE = Buffer.from("75bba79a376142a7bacbf95d791126d3", "hex");
+function legacySkillEntryId(skillId, analyzedAt) {
+  const bytes = (0, import_node_crypto3.createHash)("sha1").update(SKILL_ENTRY_ID_NAMESPACE).update(`${skillId.toLowerCase()}:${analyzedAt}`).digest().subarray(0, 16);
+  bytes[6] = (bytes[6] ?? 0) & 15 | 80;
+  bytes[8] = (bytes[8] ?? 0) & 63 | 128;
+  const hex = bytes.toString("hex");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+function resolveSkillVerdictEntryId(skillId, entry) {
+  return entry.entryId ?? legacySkillEntryId(skillId, entry.analyzedAt);
+}
 
 // ../core/dist/plugin-scanner.js
 init_types2();
@@ -21341,12 +21568,12 @@ var MAX_FILE_SIZE = 512 * 1024;
 
 // ../core/dist/product-version.js
 var import_node_fs = require("node:fs");
-var import_node_path7 = __toESM(require("node:path"), 1);
+var import_node_path9 = __toESM(require("node:path"), 1);
 function readProductJsonVersion(appRoot) {
   if (!appRoot)
     return "unknown";
   try {
-    const productJsonPath = import_node_path7.default.join(appRoot, "product.json");
+    const productJsonPath = import_node_path9.default.join(appRoot, "product.json");
     const raw = (0, import_node_fs.readFileSync)(productJsonPath, "utf8");
     const parsed = JSON.parse(raw);
     const version2 = parsed.version;
@@ -31409,7 +31636,7 @@ var StdioServerTransport = class {
 };
 
 // ../mcp/dist/tools/false-positive.js
-var import_node_crypto2 = require("node:crypto");
+var import_node_crypto4 = require("node:crypto");
 init_zod();
 
 // ../mcp/dist/tools/utils.js
@@ -31445,7 +31672,63 @@ function readContentSnippet(entry) {
 function isRuntimeVerdictEntry(v) {
   if (!v || typeof v !== "object" || Array.isArray(v))
     return false;
-  return v.type === "runtime_verdict";
+  const entry = v;
+  return entry.type === "runtime_verdict" && (entry.custom_threat_matched !== true || entry.non_custom_detection_matched === true || hasReportableDetectionSignals(parseRuntimeAuditSignals(entry.signals)));
+}
+function isAnalyzedSkillVerdictEntry(v) {
+  if (!v || typeof v !== "object" || Array.isArray(v))
+    return false;
+  const entry = v;
+  return entry.type === "skill_verdict" && entry.status === "analyzed" && isSkillId(asString(entry.skill_id) ?? "");
+}
+function isReportableSkillVerdictEntry(v) {
+  if (!isAnalyzedSkillVerdictEntry(v))
+    return false;
+  const entry = v;
+  const verdict = asString(entry.verdict)?.toUpperCase();
+  return (verdict === "HIGH" || verdict === "CRITICAL") && asString(entry.entry_id) !== void 0;
+}
+function latestReportableSkillVerdicts(entries, ttlMs, now = Date.now()) {
+  const latestBySkillId = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (!isAnalyzedSkillVerdictEntry(entry))
+      continue;
+    const timestamp = Date.parse(asString(entry.timestamp) ?? "");
+    if (!isFreshTimestamp(timestamp, ttlMs, now))
+      continue;
+    const normalizedSkillId = entry.skill_id.toLowerCase();
+    const current = latestBySkillId.get(normalizedSkillId);
+    if (current && timestamp < current.timestamp)
+      continue;
+    latestBySkillId.delete(normalizedSkillId);
+    latestBySkillId.set(normalizedSkillId, { entry, timestamp });
+  }
+  return [...latestBySkillId.values()].map(({ entry }) => entry).filter(isReportableSkillVerdictEntry);
+}
+async function cachedSkillVerdictEntries(config2, logger2) {
+  const cache2 = await loadSkillVerdictCacheReadOnly(void 0, skillCacheTtlMs(config2), logger2);
+  return Object.entries(cache2.entries).flatMap(([skillId, entry]) => {
+    if (!isSkillId(skillId))
+      return [];
+    if (!entry.verdict)
+      return [];
+    const normalizedSkillId = skillId.toLowerCase();
+    const analyzerVerdict = entry.verdict.toUpperCase();
+    const signal = buildSkillCheckSignal(normalizedSkillId, analyzerVerdict, entry.jobId);
+    return [
+      {
+        type: "skill_verdict",
+        entry_id: resolveSkillVerdictEntryId(normalizedSkillId, entry),
+        timestamp: entry.analyzedAt,
+        agent_runtime: entry.sources?.[0]?.agentRuntime,
+        skill_id: normalizedSkillId,
+        job_id: entry.jobId,
+        status: "analyzed",
+        verdict: analyzerVerdict,
+        signals: signal ? { skill_checks: [signal] } : void 0
+      }
+    ];
+  });
 }
 function getConversationId(entry) {
   return asString(entry.conversation_id) ?? asString(entry.session_id);
@@ -31453,6 +31736,10 @@ function getConversationId(entry) {
 function getEntryId(entry) {
   return asString(entry.entry_id);
 }
+function getEntryTimestamp(entry) {
+  const timestamp = Date.parse(asString(entry.timestamp) ?? "");
+  return Number.isFinite(timestamp) ? timestamp : 0;
+}
 function asHookType(value) {
   const s = asString(value);
   if (s === "PreToolUse" || s === "PostToolUse" || s === "SessionStart" || s === "GatewayStart" || s === "BeforeAgentStart" || s === "MessagesTransform") {
@@ -31473,9 +31760,10 @@ async function postMultipart(endpoint, payload, timeoutSeconds) {
   const bodyText = await res.text().catch(() => "");
   return { ok: res.ok, status: res.status, bodyText };
 }
+var MAX_AUDIT_SCAN_ENTRIES = 5e3;
 var ListInputSchema = external_exports.object({
   conversation_id: external_exports.string().optional().describe("Conversation id to filter audit entries; if omitted, uses the most recent one."),
-  limit: external_exports.number().int().min(1).max(5e3).optional().describe("Max entries to scan and return.")
+  limit: external_exports.number().int().min(1).max(MAX_AUDIT_SCAN_ENTRIES).optional().describe("Max merged entries to return.")
 });
 var MAX_IMPLICIT_ENTRIES = 3;
 var MAX_EXPLICIT_ENTRIES = 10;
@@ -31484,10 +31772,10 @@ var ReportInputSchema = external_exports.object({
   description: external_exports.string().min(1).describe("Short description of what is a false positive."),
   reasoning: external_exports.string().min(1).describe("Reasoning for why this should be treated as a false positive."),
   agent_runtime_version: external_exports.string().optional().describe("Optional agent runtime version override (Cursor/VS Code/Claude version). If omitted, the server resolves the host version from SAGE_APP_ROOT (the application root injected by the Sage extension at MCP-server install time, used to read product.json), then falls back to SAGE_AGENT_RUNTIME_VERSION env, then 'unknown'."),
-  entry_ids: external_exports.array(external_exports.string()).optional().describe(`REQUIRED in normal use: list of specific audit entry_ids to report as false positives. ALWAYS call sage_list_audit_entries first to inspect the audit log and identify the exact deny/ask verdict the user considers a false positive, then pass its entry_id here. Up to ${MAX_EXPLICIT_ENTRIES} entry_ids may be provided per call. Omitting this parameter is a fallback that submits up to ${MAX_IMPLICIT_ENTRIES} most recent deny/ask entries for the conversation, which may include irrelevant verdicts and should only be used when entry_id discovery is impossible.`),
+  entry_ids: external_exports.array(external_exports.string()).max(MAX_EXPLICIT_ENTRIES).optional().describe(`REQUIRED in normal use: list of specific audit entry_ids to report as false positives. ALWAYS call sage_list_audit_entries first to inspect the audit log and identify the exact deny/ask verdict the user considers a false positive, then pass its entry_id here. Up to ${MAX_EXPLICIT_ENTRIES} entry_ids may be provided per call. Omitting this parameter is a fallback that submits up to ${MAX_IMPLICIT_ENTRIES} most recent deny/ask entries for the conversation, which may include irrelevant verdicts and should only be used when entry_id discovery is impossible.`),
   dry_run: external_exports.boolean().optional().describe("If true, do not POST; just show the payload.")
 });
-function parseAuditSignals(raw, options = {}) {
+function parseRuntimeAuditSignals(raw, options = {}) {
   if (!raw || typeof raw !== "object" || Array.isArray(raw))
     return {};
   const includePiContentSnippet = options.includePiContentSnippet ?? true;
@@ -31596,7 +31884,7 @@ function registerFalsePositiveTools(server, opts) {
   const branding = opts.branding ?? defaultBranding;
   server.registerTool("sage_list_audit_entries", {
     title: `${branding.name}: List Audit Entries`,
-    description: `List recent ${branding.name} audit log entries, optionally scoped to a conversation id. Useful for selecting entry_ids to report as false positives.`,
+    description: `List recent ${branding.name} runtime and Skill Analyzer audit entries. Runtime entries are optionally scoped to a conversation id; skill entries are global because analysis can finish outside the originating conversation. Useful for selecting entry_ids to report as false positives.`,
     inputSchema: ListInputSchema
   }, async ({ conversation_id, limit }) => {
     const complete = (result, data = {}) => {
@@ -31614,33 +31902,59 @@ function registerFalsePositiveTools(server, opts) {
     });
     try {
       const config2 = await loadConfig(void 0, logger2);
-      const scanLimit = limit ?? 500;
-      const entries = await getRecentEntries(config2.logging, scanLimit);
+      const outputLimit = limit ?? 500;
+      const entries = await getRecentEntries(config2.logging, MAX_AUDIT_SCAN_ENTRIES);
       const runtime = entries.filter(isRuntimeVerdictEntry);
+      const cachedSkills = await cachedSkillVerdictEntries(config2, logger2);
+      const skills = latestReportableSkillVerdicts([...entries, ...cachedSkills], skillCacheTtlMs(config2));
       const inferredConversationId = conversation_id ?? getConversationId(runtime.slice().reverse().find((e) => !!getConversationId(e)) ?? {});
-      if (!inferredConversationId) {
-        complete("skipped", { skippedReason: "no_runtime_entries", entriesReturned: 0 });
-        return textResult("No runtime_verdict entries found in the audit log.", true);
-      }
-      const filtered = runtime.filter((e) => getConversationId(e) === inferredConversationId);
-      const out = filtered.map((e) => ({
-        entry_id: getEntryId(e),
-        timestamp: asString(e.timestamp),
-        conversation_id: inferredConversationId,
-        agent_runtime: asString(e.agent_runtime),
-        tool_name: asString(e.tool_name),
-        tool_input_summary: asString(e.tool_input_summary),
-        verdict: asString(e.verdict),
-        severity: asString(e.severity),
-        source: asString(e.source),
-        user_override: e.user_override,
-        // PI snippets are untrusted fetched content. Exclude their raw
-        // text—including the generic top-level content_snippet - from this
-        // model-visible response. Retain it only for the backend-only
-        // false-positive report below.
-        signals: parseAuditSignals(e.signals, { includePiContentSnippet: false }),
-        content: readContent(e)
-      }));
+      if (!inferredConversationId && skills.length === 0) {
+        complete("skipped", { skippedReason: "no_reportable_entries", entriesReturned: 0 });
+        return textResult("No reportable runtime or skill verdict entries found.", true);
+      }
+      const filteredRuntime = inferredConversationId ? runtime.filter((e) => getConversationId(e) === inferredConversationId) : [];
+      const selected = [
+        ...filteredRuntime,
+        ...skills
+      ].sort((a, b) => getEntryTimestamp(a) - getEntryTimestamp(b)).slice(-outputLimit);
+      const out = selected.map((entry) => {
+        if (isReportableSkillVerdictEntry(entry)) {
+          const skillId = entry.skill_id;
+          const analyzerVerdict = asString(entry.verdict)?.toUpperCase() ?? "";
+          const signal = buildSkillCheckSignal(skillId, analyzerVerdict, asString(entry.job_id));
+          return {
+            type: "skill_verdict",
+            entry_id: getEntryId(entry),
+            timestamp: asString(entry.timestamp),
+            agent_runtime: asString(entry.agent_runtime),
+            skill_id: skillId.toLowerCase(),
+            job_id: asString(entry.job_id),
+            status: asString(entry.status),
+            analyzer_verdict: analyzerVerdict,
+            signals: signal ? { skill_checks: [signal] } : {}
+          };
+        }
+        const runtimeEntry = entry;
+        return {
+          type: "runtime_verdict",
+          entry_id: getEntryId(runtimeEntry),
+          timestamp: asString(runtimeEntry.timestamp),
+          conversation_id: inferredConversationId,
+          agent_runtime: asString(runtimeEntry.agent_runtime),
+          tool_name: asString(runtimeEntry.tool_name),
+          tool_input_summary: asString(runtimeEntry.tool_input_summary),
+          verdict: asString(runtimeEntry.verdict),
+          severity: asString(runtimeEntry.severity),
+          source: asString(runtimeEntry.source),
+          user_override: runtimeEntry.user_override,
+          // PI snippets are untrusted fetched content. Exclude their raw
+          // text from this model-visible response.
+          signals: parseRuntimeAuditSignals(runtimeEntry.signals, {
+            includePiContentSnippet: false
+          }),
+          content: readContent(runtimeEntry)
+        };
+      });
       complete("completed", {
         conversationId: inferredConversationId,
         entriesReturned: out.length
@@ -31657,11 +31971,11 @@ function registerFalsePositiveTools(server, opts) {
   });
   server.registerTool("sage_report_false_positive", {
     title: `${branding.name}: Report False Positive`,
-    description: `Report ${branding.name} audit log entries as false positives to the backend, scoped to the current conversation.
+    description: `Report ${branding.name} runtime or Skill Analyzer audit entries as false positives to the backend. Runtime entries are scoped to the current conversation; skill entries require explicit entry_ids.
 
 USAGE \u2014 IMPORTANT:
-1. ALWAYS call \`sage_list_audit_entries\` FIRST to inspect the audit log and locate the specific deny/ask verdict the user considers a false positive.
-2. ALWAYS pass the \`entry_ids\` parameter with just the relevant deny/ask entry id(s). Up to ${MAX_EXPLICIT_ENTRIES} entry_ids may be reported per call.
+1. ALWAYS call \`sage_list_audit_entries\` FIRST to inspect the audit log and locate the specific runtime or skill verdict the user considers a false positive.
+2. ALWAYS pass the \`entry_ids\` parameter with just the relevant entry id(s); it is required for skill verdicts. Up to ${MAX_EXPLICIT_ENTRIES} entry_ids may be reported per call.
 3. Only when entry_id discovery is impossible should \`entry_ids\` be omitted; in that fallback at most ${MAX_IMPLICIT_ENTRIES} most recent deny/ask entries for the conversation are submitted, which may include irrelevant verdicts and floods the backend with noise.`,
     inputSchema: ReportInputSchema
   }, async ({ conversation_id, description, reasoning, agent_runtime_version, entry_ids, dry_run }) => {
@@ -31685,31 +31999,35 @@ USAGE \u2014 IMPORTANT:
       const config2 = await loadConfig(void 0, logger2);
       const endpoint = resolveEndpoint("/v2/fp-report");
       const timeoutSeconds = Number(process.env.SAGE_FALSE_POSITIVE_TIMEOUT_SECONDS) || 5;
-      const scanLimit = 2e3;
-      const entries = await getRecentEntries(config2.logging, scanLimit);
+      const entries = await getRecentEntries(config2.logging, MAX_AUDIT_SCAN_ENTRIES);
       const runtime = entries.filter(isRuntimeVerdictEntry);
+      const cachedSkills = await cachedSkillVerdictEntries(config2, logger2);
+      const skills = latestReportableSkillVerdicts([...entries, ...cachedSkills], skillCacheTtlMs(config2));
       const inferredConversationId = conversation_id ?? getConversationId(runtime.slice().reverse().find((e) => !!getConversationId(e)) ?? {});
-      if (!inferredConversationId) {
-        complete("skipped", { skippedReason: "no_runtime_entries", reportsCount: 0 });
-        return textResult("No runtime_verdict entries found in the audit log.", true);
-      }
-      let filtered = runtime.filter((e) => getConversationId(e) === inferredConversationId);
+      let filtered;
       if (entry_ids && entry_ids.length > 0) {
-        const wanted = new Set(entry_ids);
-        filtered = filtered.filter((e) => {
-          const id = getEntryId(e);
-          return id ? wanted.has(id) : false;
-        });
-        if (filtered.length > MAX_EXPLICIT_ENTRIES) {
+        if (entry_ids.length > MAX_EXPLICIT_ENTRIES) {
           complete("failed_validation", {
             conversationId: inferredConversationId,
-            reportsCount: filtered.length,
+            entryIdsCount: entry_ids.length,
             maxEntries: MAX_EXPLICIT_ENTRIES
           });
-          return textResult(`Too many entry_ids (${filtered.length}). Provide at most ${MAX_EXPLICIT_ENTRIES} specific entry_ids per report call.`, true);
+          return textResult(`Too many entry_ids (${entry_ids.length}). Provide at most ${MAX_EXPLICIT_ENTRIES} specific entry_ids per report call.`, true);
         }
+        const wanted = new Set(entry_ids);
+        const scopedRuntime = inferredConversationId ? runtime.filter((e) => getConversationId(e) === inferredConversationId) : [];
+        filtered = [...scopedRuntime, ...skills].filter((e) => {
+          const id = getEntryId(e);
+          return id !== void 0 && wanted.has(id);
+        });
       } else {
-        filtered = filtered.filter((e) => {
+        if (!inferredConversationId) {
+          complete("skipped", { skippedReason: "no_runtime_entries", reportsCount: 0 });
+          return textResult("No runtime_verdict entries found. Skill verdicts must be reported with explicit entry_ids.", true);
+        }
+        filtered = runtime.filter((e) => {
+          if (getConversationId(e) !== inferredConversationId)
+            return false;
           const v = asString(e.verdict);
           return v === "deny" || v === "ask";
         });
@@ -31724,7 +32042,7 @@ USAGE \u2014 IMPORTANT:
             skippedReason: "no_matching_entry_ids",
             reportsCount: 0
           });
-          return textResult("No matching audit entries found for the provided entry_ids in this conversation. Run sage_list_audit_entries first.", true);
+          return textResult("No matching reportable audit entries found for the provided entry_ids. Run sage_list_audit_entries first.", true);
         }
         complete("skipped", {
           conversationId: inferredConversationId,
@@ -31750,19 +32068,22 @@ USAGE \u2014 IMPORTANT:
 ${reasoning}`;
       const extendedInfo = await loadExtendedInfo(void 0, logger2).catch(() => null);
       const reports = filtered.map((e) => {
+        const isSkill = isReportableSkillVerdictEntry(e);
+        const runtimeEntry = isSkill ? void 0 : e;
         const entry_id = getEntryId(e);
         const timestamp = asString(e.timestamp) ?? (/* @__PURE__ */ new Date()).toISOString();
         const agent_runtime = asString(e.agent_runtime) ?? "unknown";
-        const tool_type = asString(e.tool_name) ?? "Unknown";
-        const verdict = asString(e.verdict) ?? "deny";
-        const wasAllowed = verdict === "allow" || e.user_override === true;
+        const analyzerVerdict = isSkill ? asString(e.verdict)?.toUpperCase() : void 0;
+        const tool_type = isSkill ? "Skill" : asString(runtimeEntry?.tool_name) ?? "Unknown";
+        const verdict = isSkill ? analyzerVerdict === "CRITICAL" ? "deny" : "ask" : asString(e.verdict) ?? "deny";
+        const wasAllowed = !isSkill && (verdict === "allow" || runtimeEntry?.user_override === true);
         const user_action = wasAllowed ? "allowed" : "blocked";
-        const hook_type = asHookType(e.hook_type) ?? "PreToolUse";
-        const signals = parseAuditSignals(e.signals, {
+        const hook_type = isSkill ? "SessionStart" : asHookType(runtimeEntry?.hook_type) ?? "PreToolUse";
+        const signals = parseRuntimeAuditSignals(e.signals, {
           includePiContentSnippet: !dry_run
         });
-        const content = readContent(e);
-        const contentSnippet = readContentSnippet(e);
+        const content = runtimeEntry ? readContent(runtimeEntry) : {};
+        const contentSnippet = runtimeEntry ? readContentSnippet(runtimeEntry) : void 0;
         const bestEffortSignals = {};
         if (signals.heuristics)
           bestEffortSignals.heuristics = signals.heuristics;
@@ -31776,6 +32097,11 @@ ${reasoning}`;
           bestEffortSignals.pi_checks = signals.pi_checks;
         if (signals.amsi_checks)
           bestEffortSignals.amsi_checks = signals.amsi_checks;
+        if (isSkill) {
+          const signal = analyzerVerdict ? buildSkillCheckSignal(e.skill_id, analyzerVerdict, asString(e.job_id)) : void 0;
+          if (signal)
+            bestEffortSignals.skill_checks = [signal];
+        }
         const baseReportPayload = {
           ...buildSageProxyEnvelope({
             iid,
@@ -31791,11 +32117,11 @@ ${reasoning}`;
             user_action,
             timestamp,
             ...Object.keys(bestEffortSignals).length > 0 ? { signals: bestEffortSignals } : {},
-            content,
+            ...Object.keys(content).length > 0 ? { content } : {},
             ...contentSnippet && !dry_run ? { content_snippet: contentSnippet } : {}
           },
           comment,
-          event_id: entry_id ?? (0, import_node_crypto2.randomUUID)()
+          event_id: entry_id ?? (0, import_node_crypto4.randomUUID)()
         };
         const reportPayload = mergeExtendedInfo(baseReportPayload, extendedInfo);
         return { entry_id, payload: reportPayload };
@@ -31849,7 +32175,8 @@ ${JSON.stringify(summary, null, 2)}`, true);
         conversationId: inferredConversationId,
         reported: filtered.length
       });
-      return textResult(`Reported ${filtered.length} audit entr${filtered.length === 1 ? "y" : "ies"} for conversation_id=${inferredConversationId}.`);
+      const scope = inferredConversationId ? ` for conversation_id=${inferredConversationId}` : "";
+      return textResult(`Reported ${filtered.length} audit entr${filtered.length === 1 ? "y" : "ies"}${scope}.`);
     } catch (e) {
       logger2.warn("MCP tool failed", {
         toolName: "sage_report_false_positive",
@@ -31897,7 +32224,7 @@ async function main() {
   );
   const branding = resolveBranding(config2.brand_key, logger);
   await runSageMcpServerStdio({
-    version: "0.13.0",
+    version: "0.15.0",
     logger,
     branding
   });