@gendigital/sage-openclaw 0.11.0 → 0.13.0

package/dist/index.cjs

@@ -63,7 +63,7 @@ async function renameWithRetry(from, to, attempts = 5) {
       const transient = code === "EPERM" || code === "EACCES" || code === "EBUSY";
       if (!transient || i === attempts - 1)
         throw err;
-      await new Promise((resolve9) => setTimeout(resolve9, 10 * 2 ** i));
+      await new Promise((resolve10) => setTimeout(resolve10, 10 * 2 ** i));
     }
   }
 }
@@ -130,7 +130,47 @@ async function pruneOrphanedModelDownloads(stagingDir, maxAgeMs = 60 * 60 * 1e3)
     }
   }
 }
-var import_node_crypto, fs, fsPromises, import_node_os, import_node_path, name1, name2;
+async function removeStaleFileLock(lockPath, staleAgeMs) {
+  try {
+    const s = await fsPromises.stat(lockPath);
+    if (Date.now() - s.mtimeMs < staleAgeMs)
+      return;
+    await fsPromises.rmdir(lockPath);
+  } catch {
+  }
+}
+async function acquireFileLock(filePath, timeoutMs = 250, staleAgeMs = 3e4) {
+  const lockPath = `${filePath}.lock`;
+  const deadline = Date.now() + timeoutMs;
+  while (true) {
+    try {
+      await fsPromises.mkdir(lockPath);
+      return async () => {
+        try {
+          await fsPromises.rmdir(lockPath);
+        } catch {
+        }
+      };
+    } catch {
+      await removeStaleFileLock(lockPath, staleAgeMs);
+      const remainingMs = deadline - Date.now();
+      if (remainingMs <= 0)
+        return void 0;
+      await (0, import_promises.setTimeout)(Math.min(50, remainingMs));
+    }
+  }
+}
+async function withFileLock(filePath, callback) {
+  const release = await acquireFileLock(filePath);
+  if (!release)
+    return;
+  try {
+    return await callback();
+  } finally {
+    await release();
+  }
+}
+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";
@@ -139,6 +179,7 @@ var init_file_utils = __esm({
     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";
   }
@@ -4251,7 +4292,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, DEFAULT_PI_HIGH_RISK_THRESHOLD, DEFAULT_PI_MEDIUM_RISK_THRESHOLD, 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_HIGH_RISK_THRESHOLD, DEFAULT_PI_MEDIUM_RISK_THRESHOLD, DEFAULT_PI_TELEMETRY_THRESHOLD, PiCheckConfigSchema, ExceptionDecisionSchema, ExceptionMatchSchema, ExceptionRuleSchema, ExceptionsFileSchema, ExceptionsConfigSchema, ConfigSchema, HookTypeSchema;
 var init_types2 = __esm({
   "../core/dist/types.js"() {
     "use strict";
@@ -4275,7 +4316,8 @@ var init_types2 = __esm({
     VerdictSeveritySchema = external_exports.enum(["info", "warning", "critical"]);
     ThreatSchema = external_exports.object({
       id: external_exports.string(),
-      version: external_exports.number().int().optional(),
+      version: external_exports.number().int().positive(),
+      detectionName: external_exports.string(),
       category: external_exports.string(),
       severity: VerdictSeveritySchema,
       confidence: external_exports.number(),
@@ -4328,14 +4370,24 @@ var init_types2 = __esm({
     AmsiCheckConfigSchema = external_exports.object({
       enabled: external_exports.boolean().default(true)
     });
+    SkillCheckConfigSchema = external_exports.object({
+      enabled: external_exports.boolean().default(true),
+      cache_ttl_days: external_exports.number().min(0).default(1),
+      /**
+       * Upload unknown skills (never seen by the analyzer) for deep content
+       * analysis. When false, the scan still looks skills up by content hash and
+       * still flags known-risky ones — but no skill content ever leaves the
+       * machine and the upload worker never runs (lookup-only mode).
+       */
+      upload_enabled: external_exports.boolean().default(true)
+    });
     DEFAULT_PI_HIGH_RISK_THRESHOLD = 0.99;
     DEFAULT_PI_MEDIUM_RISK_THRESHOLD = 0.5;
+    DEFAULT_PI_TELEMETRY_THRESHOLD = 0.95;
     PiCheckConfigSchema = external_exports.object({
       enabled: external_exports.boolean().default(false),
       max_content_length: external_exports.number().default(16384),
-      model_path: external_exports.string().optional(),
-      high_risk_threshold: external_exports.number().default(DEFAULT_PI_HIGH_RISK_THRESHOLD),
-      medium_risk_threshold: external_exports.number().default(DEFAULT_PI_MEDIUM_RISK_THRESHOLD)
+      model_path: external_exports.string().optional()
     });
     ExceptionDecisionSchema = external_exports.enum(["allow", "deny"]);
     ExceptionMatchSchema = external_exports.enum(["executable", "domain", "path", "plugin", "regex"]);
@@ -4357,6 +4409,7 @@ var init_types2 = __esm({
       file_check: FileCheckConfigSchema.default({}),
       package_check: PackageCheckConfigSchema.default({}),
       amsi_check: AmsiCheckConfigSchema.default({}),
+      skill_check: SkillCheckConfigSchema.default({}),
       pi_check: PiCheckConfigSchema.default({}),
       heuristics_enabled: external_exports.boolean().default(true),
       cache: CacheConfigSchema.default({}),
@@ -4365,6 +4418,8 @@ var init_types2 = __esm({
       operational_logging: OperationalLoggingConfigSchema.default({}),
       sensitivity: SensitivitySchema.default("balanced"),
       disabled_threats: external_exports.array(external_exports.string()).default([]),
+      announce_clean_scans: external_exports.boolean().default(true),
+      manage_status_line: external_exports.boolean().default(true),
       brand_key: external_exports.string().min(1).max(32).regex(/^[a-z0-9_-]+$/u).optional(),
       community_iq: external_exports.boolean().default(true)
     });
@@ -4383,13 +4438,27 @@ var init_types2 = __esm({
 var config_exports = {};
 __export(config_exports, {
   HOOK_TIMEOUT_SECONDS: () => HOOK_TIMEOUT_SECONDS,
+  MS_PER_DAY: () => MS_PER_DAY,
   SAGE_DIR: () => SAGE_DIR,
   defaultConfigPath: () => defaultConfigPath,
   getClaudeConfigDir: () => getClaudeConfigDir,
+  isFreshTimestamp: () => isFreshTimestamp,
   loadConfig: () => loadConfig,
   loadConfigSync: () => loadConfigSync,
-  resolvePath: () => resolvePath
+  readExplicitSkillUploadEnabled: () => readExplicitSkillUploadEnabled,
+  resolvePath: () => resolvePath,
+  skillCacheTtlMs: () => skillCacheTtlMs
 });
+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);
 }
@@ -4464,7 +4533,7 @@ function sanitizeBrandKey(data, logger) {
   if (typeof brandKey === "string" && brandKey.length >= 1 && brandKey.length <= 32 && BRAND_KEY_RE.test(brandKey)) {
     return data;
   }
-  logger.warn(`Invalid brand_key in config \u2014 ignoring`, { brand_key: brandKey });
+  logger.warn(`Invalid brand_key in config - ignoring`, { brand_key: brandKey });
   const { brand_key: _, ...rest } = data;
   return rest;
 }
@@ -4516,6 +4585,21 @@ function parseConfig(raw, path, logger) {
     return defaultConfig(logger);
   }
 }
+async function readExplicitSkillUploadEnabled(configPath, logger = nullLogger) {
+  const path = configPath ? resolvePath(configPath) : defaultConfigPath();
+  try {
+    const data = JSON.parse(await getFileContent(path));
+    const skillCheck = data.skill_check;
+    if (skillCheck && typeof skillCheck === "object" && !Array.isArray(skillCheck) && "upload_enabled" in skillCheck) {
+      const value = skillCheck.upload_enabled;
+      if (typeof value === "boolean")
+        return { present: true, value };
+      logger.warn("Config skill_check.upload_enabled is not a boolean; ignoring", { value });
+    }
+  } catch {
+  }
+  return { present: false, value: false };
+}
 async function loadConfig(configPath, logger = nullLogger) {
   const path = configPath ? resolvePath(configPath) : defaultConfigPath();
   try {
@@ -4532,7 +4616,7 @@ function loadConfigSync(configPath, logger = nullLogger) {
     return defaultConfig(logger);
   }
 }
-var import_node_path2, SAGE_DIR, HOOK_TIMEOUT_SECONDS, BRAND_KEY_RE;
+var import_node_path2, SAGE_DIR, HOOK_TIMEOUT_SECONDS, MS_PER_DAY, CLOCK_SKEW_TOLERANCE_MS, BRAND_KEY_RE;
 var init_config = __esm({
   "../core/dist/config.js"() {
     "use strict";
@@ -4541,6 +4625,8 @@ var init_config = __esm({
     init_types2();
     SAGE_DIR = "~/.sage";
     HOOK_TIMEOUT_SECONDS = 8;
+    MS_PER_DAY = 24 * 60 * 60 * 1e3;
+    CLOCK_SKEW_TOLERANCE_MS = 5 * 60 * 1e3;
     BRAND_KEY_RE = /^[a-z0-9_-]+$/u;
   }
 });
@@ -6805,7 +6891,7 @@ async function ensurePiDeps(modelPath, logger = nullLogger) {
   }
 }
 function runNpm(cwd, args, logger) {
-  return new Promise((resolve9, reject) => {
+  return new Promise((resolve10, reject) => {
     const isWindows = process.platform === "win32";
     const npmCmd = isWindows ? "npm.cmd" : "npm";
     const child = (0, import_node_child_process.execFile)(npmCmd, args, { cwd, timeout: 3e4, shell: isWindows }, (error, _stdout, stderr) => {
@@ -6813,7 +6899,7 @@ function runNpm(cwd, args, logger) {
         logger.warn(`npm install error: ${stderr || error.message}`);
         reject(error);
       } else {
-        resolve9();
+        resolve10();
       }
     });
     child.unref();
@@ -14139,7 +14225,7 @@ function resolveBranding(brandKey, logger) {
     return defaultBranding;
   const entry = BRANDS[brandKey];
   if (!entry) {
-    logger?.warn(`Unknown brand_key "${brandKey}" in config \u2014 using default branding`);
+    logger?.warn(`Unknown brand_key "${brandKey}" in config - using default branding`);
     return defaultBranding;
   }
   return { ...entry, brand_key: brandKey };
@@ -14239,88 +14325,226 @@ var ApprovalStore = class {
 // ../core/dist/audit-log.js
 var import_node_crypto3 = require("node:crypto");
 init_config();
+
+// ../core/dist/content-snapshot.js
+var import_node_os2 = require("node:os");
+var CONTENT_FIELD_LIMITS = Object.freeze({
+  command: 512,
+  url: 512,
+  file_path: 512,
+  package_name: 256,
+  package_version: 128,
+  package_registry: 128
+});
+function safeTruncate(value, maxLen) {
+  if (maxLen <= 0)
+    return "";
+  if (value.length <= maxLen)
+    return value;
+  const cutIndex = maxLen;
+  const codeUnit = value.charCodeAt(cutIndex - 1);
+  if (codeUnit >= 55296 && codeUnit <= 56319) {
+    return value.slice(0, cutIndex - 1);
+  }
+  return value.slice(0, cutIndex);
+}
+function scrubHomePath(value) {
+  const home = (0, import_node_os2.homedir)();
+  if (!home)
+    return value;
+  const normalizedHome = home.replace(/\\/g, "/").replace(/\/+$/, "");
+  if (!normalizedHome)
+    return value;
+  const normalizedValue = value.replace(/\\/g, "/");
+  if (normalizedValue === normalizedHome)
+    return "~";
+  if (normalizedValue.startsWith(`${normalizedHome}/`)) {
+    return `~/${normalizedValue.slice(normalizedHome.length + 1)}`;
+  }
+  return value;
+}
+function asString(v) {
+  return typeof v === "string" && v.length > 0 ? v : void 0;
+}
+function resolveFilePath(toolInput) {
+  return asString(toolInput.file_path) ?? asString(toolInput.filePath) ?? asString(toolInput.path);
+}
+function resolveWebFetchUrl(toolInput) {
+  const single = asString(toolInput.url);
+  if (single)
+    return single;
+  const urls = toolInput.urls;
+  if (Array.isArray(urls)) {
+    for (const u of urls) {
+      if (typeof u === "string" && u.length > 0)
+        return u;
+    }
+  }
+  return void 0;
+}
+function extractFirstApplyPatchPath(patchText) {
+  if (!patchText)
+    return void 0;
+  const headerMatch = /\*{3}\s+(?:Add|Update|Delete)\s+File:\s*(.+)/.exec(patchText);
+  if (headerMatch?.[1]) {
+    const trimmed = headerMatch[1].trim();
+    if (trimmed)
+      return trimmed;
+  }
+  const renameMatch = /\*{3}\s+(?:Move\s+to|Rename\s+File):\s*(.+)/i.exec(patchText);
+  if (renameMatch?.[1]) {
+    const raw = renameMatch[1].trim();
+    const arrow = raw.indexOf(" -> ");
+    if (arrow !== -1) {
+      const src = raw.slice(0, arrow).trim();
+      if (src)
+        return src;
+      const dst = raw.slice(arrow + 4).trim();
+      if (dst)
+        return dst;
+    } else if (raw) {
+      return raw;
+    }
+  }
+  return void 0;
+}
+function extractMcpContent(toolInput) {
+  const nestedRaw = toolInput.tool_input ?? toolInput.toolInput;
+  const candidate = nestedRaw && typeof nestedRaw === "object" && !Array.isArray(nestedRaw) ? nestedRaw : toolInput;
+  return {
+    command: asString(candidate.command),
+    url: asString(candidate.url) ?? resolveWebFetchUrl(candidate),
+    file_path: resolveFilePath(candidate)
+  };
+}
+function firstUrlArtifact(artifacts) {
+  for (const a of artifacts) {
+    if (a.type === "url" && typeof a.value === "string" && a.value.length > 0) {
+      return a.value;
+    }
+  }
+  return void 0;
+}
+function applyFieldLimits(content) {
+  for (const [key, value] of Object.entries(content)) {
+    if (typeof value !== "string")
+      continue;
+    let sanitized = value;
+    if (key === "file_path" || key === "command") {
+      sanitized = scrubHomePath(sanitized);
+    }
+    const limit = CONTENT_FIELD_LIMITS[key];
+    if (limit && sanitized.length > limit) {
+      sanitized = safeTruncate(sanitized, limit);
+    }
+    content[key] = sanitized;
+  }
+}
+function buildContentSnapshot(toolType, toolInput, artifacts = [], signals = {}) {
+  const content = {};
+  switch (toolType) {
+    case "Bash": {
+      const command = asString(toolInput.command);
+      if (command)
+        content.command = command;
+      break;
+    }
+    case "WebFetch": {
+      const url = resolveWebFetchUrl(toolInput) ?? firstUrlArtifact(artifacts);
+      if (url)
+        content.url = url;
+      break;
+    }
+    case "Write":
+    case "Edit":
+    case "Read":
+    case "Delete": {
+      const filePath = resolveFilePath(toolInput);
+      if (filePath)
+        content.file_path = filePath;
+      break;
+    }
+    case "ApplyPatch": {
+      const patchText = asString(toolInput.input) ?? asString(toolInput.patch) ?? "";
+      const filePath = extractFirstApplyPatchPath(patchText);
+      if (filePath)
+        content.file_path = filePath;
+      break;
+    }
+    case "MCP": {
+      const mcp = extractMcpContent(toolInput);
+      if (mcp.command)
+        content.command = mcp.command;
+      if (mcp.url)
+        content.url = mcp.url;
+      if (mcp.file_path)
+        content.file_path = mcp.file_path;
+      break;
+    }
+  }
+  if (!content.url && signals.url_checks && signals.url_checks.length > 0) {
+    const firstUrl = signals.url_checks[0]?.url;
+    if (firstUrl)
+      content.url = firstUrl;
+  }
+  if (signals.package_checks && signals.package_checks.length > 0) {
+    const p = signals.package_checks[0];
+    if (p?.package_name)
+      content.package_name = p.package_name;
+    if (p?.package_version)
+      content.package_version = p.package_version;
+    if (p?.package_registry)
+      content.package_registry = p.package_registry;
+  }
+  applyFieldLimits(content);
+  return content;
+}
+
+// ../core/dist/audit-log.js
 init_file_utils();
 
 // ../core/dist/jsonl-log-writer.js
-var import_promises = require("node:fs/promises");
+var import_promises2 = require("node:fs/promises");
 var import_node_path4 = require("node:path");
-var import_promises2 = require("node:timers/promises");
 init_config();
+init_file_utils();
 var writeQueues = /* @__PURE__ */ new Map();
-var ROTATE_LOCK_TIMEOUT_MS = 250;
-var ROTATE_LOCK_STALE_MS = 3e4;
-var ROTATE_LOCK_POLL_MS = 50;
 async function shouldRotate(filePath, maxBytes, maxFiles) {
   if (maxBytes <= 0 || maxFiles <= 0)
     return false;
   try {
-    const s = await (0, import_promises.stat)(filePath);
+    const s = await (0, import_promises2.stat)(filePath);
     return s.size >= maxBytes;
   } catch {
     return false;
   }
 }
-async function removeStaleRotateLock(lockPath) {
-  try {
-    const s = await (0, import_promises.stat)(lockPath);
-    if (Date.now() - s.mtimeMs < ROTATE_LOCK_STALE_MS)
-      return;
-    await (0, import_promises.rmdir)(lockPath);
-  } catch {
-  }
-}
-async function acquireRotateLock(filePath) {
-  const lockPath = `${filePath}.lock`;
-  const deadline = Date.now() + ROTATE_LOCK_TIMEOUT_MS;
-  while (true) {
-    try {
-      await (0, import_promises.mkdir)(lockPath);
-      return async () => {
-        try {
-          await (0, import_promises.rmdir)(lockPath);
-        } catch {
-        }
-      };
-    } catch {
-      await removeStaleRotateLock(lockPath);
-      const remainingMs = deadline - Date.now();
-      if (remainingMs <= 0)
-        return void 0;
-      await (0, import_promises2.setTimeout)(Math.min(ROTATE_LOCK_POLL_MS, remainingMs));
-    }
-  }
-}
 async function rotateIfNeeded(filePath, maxBytes, maxFiles) {
   if (!await shouldRotate(filePath, maxBytes, maxFiles))
     return;
-  const releaseLock = await acquireRotateLock(filePath);
-  if (!releaseLock)
-    return;
-  try {
+  await withFileLock(filePath, async () => {
     if (!await shouldRotate(filePath, maxBytes, maxFiles))
       return;
     try {
-      await (0, import_promises.unlink)(`${filePath}.${maxFiles}`);
+      await (0, import_promises2.unlink)(`${filePath}.${maxFiles}`);
     } catch {
     }
     for (let i = maxFiles - 1; i >= 1; i--) {
       try {
-        await (0, import_promises.rename)(`${filePath}.${i}`, `${filePath}.${i + 1}`);
+        await (0, import_promises2.rename)(`${filePath}.${i}`, `${filePath}.${i + 1}`);
       } catch {
       }
     }
     try {
-      await (0, import_promises.rename)(filePath, `${filePath}.1`);
+      await (0, import_promises2.rename)(filePath, `${filePath}.1`);
     } catch {
     }
-  } finally {
-    await releaseLock();
-  }
+  });
 }
 async function appendJsonlEntryNow(path, config2, entry) {
-  await (0, import_promises.mkdir)((0, import_node_path4.dirname)(path), { recursive: true });
+  await (0, import_promises2.mkdir)((0, import_node_path4.dirname)(path), { recursive: true });
   await rotateIfNeeded(path, config2.max_bytes, config2.max_files);
-  await (0, import_promises.appendFile)(path, `${JSON.stringify(entry)}
+  await (0, import_promises2.appendFile)(path, `${JSON.stringify(entry)}
 `);
 }
 async function appendJsonlEntry(config2, entry) {
@@ -14338,6 +14562,7 @@ async function appendJsonlEntry(config2, entry) {
 }
 
 // ../core/dist/audit-log.js
+init_types2();
 var MAX_SUMMARY_LEN = 200;
 var AUDIT_LOG_SCHEMA_VERSION = 1;
 function toolInputSummary(toolName, toolInput) {
@@ -14378,6 +14603,7 @@ async function logVerdict(config2, input) {
     severity: input.verdict.severity,
     reasons: input.verdict.reasons,
     source: input.verdict.source,
+    threat_id: input.verdict.matchedThreatId,
     user_override: userOverride,
     signals: input.signals,
     tool_use_id: input.toolUseId
@@ -14385,6 +14611,9 @@ async function logVerdict(config2, input) {
   if (input.content !== void 0) {
     entry.content = input.content;
   }
+  if (input.contentSnippet !== void 0) {
+    entry.content_snippet = input.contentSnippet;
+  }
   try {
     await appendEntry(config2, entry);
   } catch {
@@ -14406,6 +14635,22 @@ async function logPluginScan(config2, pluginKey, pluginVersion, findings) {
   } catch {
   }
 }
+async function logSkillQueued(config2, skillId, pluginKey, skillFolder) {
+  if (!config2.enabled)
+    return;
+  try {
+    await appendEntry(config2, {
+      type: "skill_queued",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      skill_id: skillId,
+      plugin_key: pluginKey,
+      // Home-scrubbed folder path: aids forensics when the same skill id shows
+      // up under multiple plugins. Omitted when the caller has no path.
+      ...skillFolder ? { skill_folder: scrubHomePath(skillFolder) } : {}
+    });
+  } catch {
+  }
+}
 
 // ../core/dist/cache.js
 init_config();
@@ -14844,19 +15089,19 @@ var PersistentPowershellAmsiBackend = class {
     return this.available;
   }
   waitForLine(timeout) {
-    return new Promise((resolve9, reject) => {
+    return new Promise((resolve10, reject) => {
       const timer = setTimeout(() => {
         this.pendingResponse = null;
         reject(new Error("timeout"));
       }, timeout);
-      this.pendingResponse = { resolve: resolve9, reject, timer };
+      this.pendingResponse = { resolve: resolve10, reject, timer };
     });
   }
   async enqueueScan(operation) {
     const previous = this.scanQueue;
     let release;
-    this.scanQueue = new Promise((resolve9) => {
-      release = resolve9;
+    this.scanQueue = new Promise((resolve10) => {
+      release = resolve10;
     });
     await previous;
     try {
@@ -14904,10 +15149,10 @@ var PersistentPowershellAmsiBackend = class {
           const line = this.stdoutBuffer.slice(0, idx).trim();
           this.stdoutBuffer = this.stdoutBuffer.slice(idx + 1);
           if (this.pendingResponse) {
-            const { resolve: resolve9, timer } = this.pendingResponse;
+            const { resolve: resolve10, timer } = this.pendingResponse;
             this.pendingResponse = null;
             clearTimeout(timer);
-            resolve9(line);
+            resolve10(line);
           }
           idx = this.stdoutBuffer.indexOf("\n");
         }
@@ -15006,7 +15251,7 @@ var WslPowershellAmsiBackend = class {
     if (!this.available)
       return null;
     const truncated = content.length > MAX_SCAN_LENGTH ? content.slice(0, MAX_SCAN_LENGTH) : content;
-    return new Promise((resolve9) => {
+    return new Promise((resolve10) => {
       try {
         const ps = spawn("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", PS_ONESHOT_SCRIPT], { stdio: ["pipe", "pipe", "pipe"] });
         let stdout = "";
@@ -15016,7 +15261,7 @@ var WslPowershellAmsiBackend = class {
             ps.kill();
           } catch {
           }
-          resolve9(null);
+          resolve10(null);
         }, PS_TIMEOUT);
         ps.stdout?.on("data", (chunk) => {
           stdout += chunk.toString();
@@ -15029,7 +15274,7 @@ var WslPowershellAmsiBackend = class {
         ps.on("error", (err) => {
           clearTimeout(timer);
           this.logger.debug("AMSI: PowerShell one-shot error", { error: String(err) });
-          resolve9(null);
+          resolve10(null);
         });
         ps.on("exit", () => {
           clearTimeout(timer);
@@ -15042,11 +15287,11 @@ var WslPowershellAmsiBackend = class {
                 contentName
               });
             }
-            resolve9(null);
+            resolve10(null);
             return;
           }
           this.logger.debug("AMSI: PowerShell one-shot result", { contentName, amsiResult });
-          resolve9(interpretAmsiResult(amsiResult, content, contentName));
+          resolve10(interpretAmsiResult(amsiResult, content, contentName));
         });
         const req = JSON.stringify({ content: truncated, contentName });
         ps.stdin?.write(`${req}
@@ -15054,7 +15299,7 @@ var WslPowershellAmsiBackend = class {
         ps.stdin?.end();
       } catch (e) {
         this.logger.warn("AMSI: PowerShell one-shot failed", { error: String(e), contentName });
-        resolve9(null);
+        resolve10(null);
       }
     });
   }
@@ -15200,7 +15445,7 @@ init_file_utils();
 var import_meta = {};
 function resolveVersion() {
   if (true)
-    return "0.11.0";
+    return "0.13.0";
   try {
     const pkgPath = (0, import_node_path5.join)((0, import_node_path5.dirname)((0, import_node_url.fileURLToPath)(import_meta.url)), "..", "package.json");
     const pkg = JSON.parse(getFileContentSync(pkgPath));
@@ -15349,9 +15594,10 @@ var FileCheckClient = class {
 var import_node_fs = require("node:fs");
 var import_node_path6 = require("node:path");
 init_config();
-var MODEL_SCHEMA_VERSION = "v1";
+var MODEL_SCHEMA_VERSION = "v2";
 var REQUIRED_MODELS_BY_SCHEMA = {
-  v1: ["pi-model"]
+  v1: ["pi-model"],
+  v2: ["pi-model"]
 };
 var REQUIRED_MODEL_FILES = {
   "pi-model": [
@@ -15385,8 +15631,11 @@ function missingRequiredModels(schema = MODEL_SCHEMA_VERSION, sageDir) {
 init_types2();
 var STALE_LOCK_MS = 60 * 60 * 1e3;
 
+// ../core/dist/clients/model-manifest.js
+init_config();
+
 // ../core/dist/sage-proxy.js
-function mapSageProxyOs(platform) {
+function mapSageHostOs(platform) {
   switch (platform) {
     case "win32":
       return "WINDOWS";
@@ -15398,21 +15647,37 @@ function mapSageProxyOs(platform) {
       return platform;
   }
 }
-function mapSageProxyArchitecture(arch) {
+function mapSageHostArchitecture(arch) {
   return arch.toUpperCase();
 }
-function buildSageProxyEnvelope(args) {
+function buildSageUserConfig(config2) {
   return {
-    identity: { uuid: args.iid },
+    sensitivity: config2.sensitivity,
+    url_check_enabled: config2.url_check.enabled,
+    file_check_enabled: config2.file_check.enabled,
+    package_check_enabled: config2.package_check.enabled,
+    heuristics_enabled: config2.heuristics_enabled,
+    pi_check_enabled: config2.pi_check.enabled,
+    community_iq_enabled: config2.community_iq,
+    // Optional-chained + defaulted: real callers pass a loadConfig result (skill_check
+    // always present via the schema default), but this feeds fail-open telemetry, so a
+    // partial config must never crash the envelope build.
+    skill_check_upload_enabled: config2.skill_check?.upload_enabled ?? true
+  };
+}
+function buildSageProxyEnvelope(args) {
+  return {
+    identity: { uuid: args.iid },
     product: { version_app: args.versionApp },
     platform: {
-      os: args.platformOs ?? mapSageProxyOs(process.platform),
-      architecture: args.platformArchitecture ?? mapSageProxyArchitecture(process.arch)
+      os: args.platformOs ?? mapSageHostOs(process.platform),
+      architecture: args.platformArchitecture ?? mapSageHostArchitecture(process.arch)
     },
     agent: {
       agent_runtime: args.agentRuntime,
       agent_runtime_version: args.agentRuntimeVersion
-    }
+    },
+    ...args.config ? { config: buildSageUserConfig(args.config) } : {}
   };
 }
 
@@ -15766,14 +16031,29 @@ var BundledPiProvider = class _BundledPiProvider {
       if (truncated.length === 0)
         return null;
       const loaded = await this.ensureLoaded();
-      if (!loaded)
+      if (!loaded) {
+        this.logger.info("PI model inference skipped", {
+          context,
+          reason: "model_unavailable"
+        });
         return null;
+      }
       const chunks = this.chunkText(truncated);
+      const modelId = (0, import_node_path9.basename)(this.modelPath);
+      this.logger.info("PI model inference started", {
+        context,
+        modelId,
+        contentLength: content.length,
+        truncatedContentLength: truncated.length,
+        chunks: chunks.length
+      });
       let maxRisk = 0;
       let maxChunk = "";
+      let chunksScanned = 0;
       for (const chunk of chunks) {
         if (chunk.length < 10)
           continue;
+        chunksScanned++;
         const risk = await this.classifyChunk(chunk);
         if (risk > maxRisk) {
           maxRisk = risk;
@@ -15785,13 +16065,21 @@ var BundledPiProvider = class _BundledPiProvider {
         const snippet = maxChunk.length > 80 ? `${maxChunk.slice(0, 77)}...` : maxChunk;
         findings.push(snippet);
       }
-      return {
+      const result = {
         risk: maxRisk,
         findings,
         contentName: context,
-        modelId: (0, import_node_path9.basename)(this.modelPath),
+        modelId,
         contentSnippet: maxChunk || void 0
       };
+      this.logger.info("PI model inference completed", {
+        context,
+        modelId,
+        risk: result.risk,
+        findingsCount: result.findings.length,
+        chunksScanned
+      });
+      return result;
     } catch (err) {
       this.logger.warn("PI check failed (fail-open)", {
         error: err instanceof Error ? err.message : String(err),
@@ -15920,6 +16208,9 @@ ${content.slice(-tailLen)}`;
 // ../core/dist/index.js
 init_pi_deps_installer();
 
+// ../core/dist/clients/skill-analyze.js
+init_types2();
+
 // ../core/dist/clients/skill-check.js
 init_types2();
 var DEFAULT_TIMEOUT4 = 5;
@@ -15942,9 +16233,13 @@ var SkillCheckClient = class {
   /**
    * Check a list of skill IDs against the proxy.
    *
-   * Returns a Map keyed by skill id. A `null` value means the proxy had
-   * no opinion on that skill (analogous to a clean verdict). Skill ids
-   * not found in the response are simply absent from the map.
+   * Returns a Map keyed by skill id:
+   * - `null` — proxy had no opinion (explicit null in response, or skill absent
+   *   from an otherwise-successful response). Callers should treat this as
+   *   "unknown, queue for upload".
+   * - absent — the entire batch failed (HTTP error or network error). Callers
+   *   should fail open and skip the skill rather than enqueue it.
+   * - object — a verdict from the analyzer.
    *
    * Fails-open: on any error returns an empty Map. Per-batch errors do
    * not poison results from successful batches.
@@ -15988,8 +16283,10 @@ var SkillCheckClient = class {
       const data = await response.json();
       const results = data.results ?? {};
       for (const id of skillIds) {
-        if (!(id in results))
+        if (!(id in results)) {
+          out.set(id, null);
           continue;
+        }
         const raw = results[id];
         if (raw === null || raw === void 0) {
           out.set(id, null);
@@ -16004,17 +16301,10 @@ var SkillCheckClient = class {
     return out;
   }
   parseResult(skillId, raw) {
-    const recommendationsRaw = raw.recommendations ?? [];
-    const recommendations = recommendationsRaw.filter((r) => typeof r === "string");
-    const categoriesRaw = raw.threat_categories ?? [];
-    const threatCategories = categoriesRaw.filter((c) => typeof c === "string");
     return {
       skillId,
       verdict: typeof raw.verdict === "string" ? raw.verdict : void 0,
-      overallRiskLevel: typeof raw.overall_risk_level === "string" ? raw.overall_risk_level : void 0,
-      summary: typeof raw.summary === "string" ? raw.summary : void 0,
-      recommendations,
-      threatCategories
+      summary: typeof raw.summary === "string" ? raw.summary : void 0
     };
   }
 };
@@ -16022,6 +16312,70 @@ var SkillCheckClient = class {
 // ../core/dist/index.js
 init_config();
 
+// ../core/dist/config-defaults.js
+var import_promises3 = require("node:fs/promises");
+var import_node_path10 = require("node:path");
+init_file_utils();
+init_types2();
+var CONFIG_DEFAULTS_FILENAME = "config.default.json";
+var CONFIG_DEFAULTS_SCHEMA_VERSION = 2;
+function buildConfigDefaults() {
+  return {
+    schema_version: CONFIG_DEFAULTS_SCHEMA_VERSION,
+    ...ConfigSchema.parse({})
+  };
+}
+function serializeConfigDefaults() {
+  return `${JSON.stringify(buildConfigDefaults(), null, 2)}
+`;
+}
+function readSchemaVersion(raw) {
+  try {
+    const data = JSON.parse(raw);
+    if (typeof data !== "object" || data === null || Array.isArray(data))
+      return null;
+    const version = data.schema_version;
+    return typeof version === "number" && Number.isInteger(version) ? version : null;
+  } catch {
+    return null;
+  }
+}
+async function deployConfigDefaults(sageDirPath, logger = nullLogger) {
+  const targetPath = (0, import_node_path10.join)(sageDirPath, CONFIG_DEFAULTS_FILENAME);
+  const defaults = serializeConfigDefaults();
+  try {
+    await (0, import_promises3.mkdir)(sageDirPath, { recursive: true, mode: 448 });
+    await (0, import_promises3.chmod)(sageDirPath, 448);
+    let existing = null;
+    try {
+      existing = await (0, import_promises3.readFile)(targetPath, "utf-8");
+    } catch {
+    }
+    if (existing) {
+      const existingVersion = readSchemaVersion(existing);
+      if (existingVersion !== null && existingVersion > CONFIG_DEFAULTS_SCHEMA_VERSION) {
+        logger.warn("Deployed config defaults are newer, update your installation", {
+          path: targetPath,
+          existingVersion,
+          supportedVersion: CONFIG_DEFAULTS_SCHEMA_VERSION
+        });
+        return;
+      }
+      if (existing === defaults)
+        return;
+    }
+    await withFileLock(targetPath, async () => {
+      await (0, import_promises3.writeFile)(targetPath, defaults, { encoding: "utf-8", mode: 384 });
+      logger.debug("Deployed config defaults", {
+        path: targetPath,
+        schemaVersion: CONFIG_DEFAULTS_SCHEMA_VERSION
+      });
+    });
+  } catch (err) {
+    logger.debug("Failed to deploy config defaults", { path: targetPath, error: String(err) });
+  }
+}
+
 // ../core/dist/config-diagnostics.js
 init_config();
 init_file_utils();
@@ -16158,184 +16512,60 @@ function isScannableContent(content) {
   return SNIFF_HTML.test(head) || SNIFF_HTML_TAGS.test(head) || SNIFF_JSON.test(head) || SNIFF_XML.test(head) || SNIFF_YAML.test(head) || SNIFF_SHEBANG_SHELL.test(head) || SNIFF_SHEBANG_PYTHON.test(head) || SNIFF_PYTHON.test(head) || SNIFF_JS_TS.test(head) || SNIFF_C_CPP.test(head) || SNIFF_KOTLIN.test(head) || SNIFF_CSV.test(head);
 }
 
-// ../core/dist/content-snapshot.js
-var import_node_os2 = require("node:os");
-var CONTENT_FIELD_LIMITS = Object.freeze({
-  command: 512,
-  url: 512,
-  file_path: 512,
-  package_name: 256,
-  package_version: 128,
-  package_registry: 128
-});
-function safeTruncate(value, maxLen) {
-  if (maxLen <= 0)
-    return "";
-  if (value.length <= maxLen)
-    return value;
-  const cutIndex = maxLen;
-  const codeUnit = value.charCodeAt(cutIndex - 1);
-  if (codeUnit >= 55296 && codeUnit <= 56319) {
-    return value.slice(0, cutIndex - 1);
-  }
-  return value.slice(0, cutIndex);
-}
-function scrubHomePath(value) {
-  const home = (0, import_node_os2.homedir)();
-  if (!home)
-    return value;
-  const normalizedHome = home.replace(/\\/g, "/").replace(/\/+$/, "");
-  if (!normalizedHome)
-    return value;
-  const normalizedValue = value.replace(/\\/g, "/");
-  if (normalizedValue === normalizedHome)
-    return "~";
-  if (normalizedValue.startsWith(`${normalizedHome}/`)) {
-    return `~/${normalizedValue.slice(normalizedHome.length + 1)}`;
-  }
-  return value;
-}
-function asString(v) {
-  return typeof v === "string" && v.length > 0 ? v : void 0;
-}
-function resolveFilePath(toolInput) {
-  return asString(toolInput.file_path) ?? asString(toolInput.filePath) ?? asString(toolInput.path);
-}
-function resolveWebFetchUrl(toolInput) {
-  const single = asString(toolInput.url);
-  if (single)
-    return single;
-  const urls = toolInput.urls;
-  if (Array.isArray(urls)) {
-    for (const u of urls) {
-      if (typeof u === "string" && u.length > 0)
-        return u;
-    }
-  }
-  return void 0;
+// ../core/dist/detection-names.js
+var PI_DETECTION_NAME = "Other:SagePromptInjectionML-A [Susp]";
+var REPORTING_ENGINE_SHORTHANDS = {
+  package: "sgpk",
+  amsi: "sgam",
+  heuristics: "sghe",
+  ml: "sgml"
+};
+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}`;
 }
-function extractFirstApplyPatchPath(patchText) {
-  if (!patchText)
-    return void 0;
-  const headerMatch = /\*{3}\s+(?:Add|Update|Delete)\s+File:\s*(.+)/.exec(patchText);
-  if (headerMatch?.[1]) {
-    const trimmed = headerMatch[1].trim();
-    if (trimmed)
-      return trimmed;
-  }
-  const renameMatch = /\*{3}\s+(?:Move\s+to|Rename\s+File):\s*(.+)/i.exec(patchText);
-  if (renameMatch?.[1]) {
-    const raw = renameMatch[1].trim();
-    const arrow = raw.indexOf(" -> ");
-    if (arrow !== -1) {
-      const src = raw.slice(0, arrow).trim();
-      if (src)
-        return src;
-      const dst = raw.slice(arrow + 4).trim();
-      if (dst)
-        return dst;
-    } else if (raw) {
-      return raw;
-    }
-  }
-  return void 0;
+var PACKAGE_DETECTION_NAMES = {
+  not_found: "Other:SagePackageNotFound-A [Susp]",
+  suspicious_age: "Other:SagePackageNew-A [Susp]",
+  malicious: "Other:SagePackageMalicious-A [Trj]",
+  unknown: "Other:SagePackageUnknown-A [Susp]"
+};
+var AMSI_DETECTION_NAMES = {
+  detected: "Other:SageAmsiDetected-A [Heur]",
+  blocked_by_admin: "Other:SageAmsiBlockedByAdmin-A [Heur]",
+  unknown: "Other:SageAmsiUnknown-A [Susp]"
+};
+var AMSI_REPORTING_RULE_NAMES = {
+  detected: "AMSI_DETECTED",
+  blocked_by_admin: "AMSI_BLOCKED_BY_ADMIN",
+  unknown: "AMSI_UNKNOWN"
+};
+function isCanonicalDetectionName(name) {
+  return /^\w+:\w+-[A-Z]+ \[[^\]\r\n]+\]$/.test(name);
 }
-function extractMcpContent(toolInput) {
-  const nestedRaw = toolInput.tool_input ?? toolInput.toolInput;
-  const candidate = nestedRaw && typeof nestedRaw === "object" && !Array.isArray(nestedRaw) ? nestedRaw : toolInput;
-  return {
-    command: asString(candidate.command),
-    url: asString(candidate.url) ?? resolveWebFetchUrl(candidate),
-    file_path: resolveFilePath(candidate)
-  };
+function packageDetectionName(verdict) {
+  return PACKAGE_DETECTION_NAMES[verdict];
 }
-function firstUrlArtifact(artifacts) {
-  for (const a of artifacts) {
-    if (a.type === "url" && typeof a.value === "string" && a.value.length > 0) {
-      return a.value;
-    }
-  }
-  return void 0;
+function amsiDetectionClass(amsiResult) {
+  if (amsiResult >= 32768)
+    return "detected";
+  if (amsiResult >= 16384)
+    return "blocked_by_admin";
+  return "unknown";
 }
-function applyFieldLimits(content) {
-  for (const [key, value] of Object.entries(content)) {
-    if (typeof value !== "string")
-      continue;
-    let sanitized = value;
-    if (key === "file_path" || key === "command") {
-      sanitized = scrubHomePath(sanitized);
-    }
-    const limit = CONTENT_FIELD_LIMITS[key];
-    if (limit && sanitized.length > limit) {
-      sanitized = safeTruncate(sanitized, limit);
-    }
-    content[key] = sanitized;
-  }
+function amsiDetectionName(amsiResult) {
+  return AMSI_DETECTION_NAMES[amsiDetectionClass(amsiResult)];
 }
-function buildContentSnapshot(toolType, toolInput, artifacts = [], signals = {}) {
-  const content = {};
-  switch (toolType) {
-    case "Bash": {
-      const command = asString(toolInput.command);
-      if (command)
-        content.command = command;
-      break;
-    }
-    case "WebFetch": {
-      const url = resolveWebFetchUrl(toolInput) ?? firstUrlArtifact(artifacts);
-      if (url)
-        content.url = url;
-      break;
-    }
-    case "Write":
-    case "Edit":
-    case "Read":
-    case "Delete": {
-      const filePath = resolveFilePath(toolInput);
-      if (filePath)
-        content.file_path = filePath;
-      break;
-    }
-    case "ApplyPatch": {
-      const patchText = asString(toolInput.input) ?? asString(toolInput.patch) ?? "";
-      const filePath = extractFirstApplyPatchPath(patchText);
-      if (filePath)
-        content.file_path = filePath;
-      break;
-    }
-    case "MCP": {
-      const mcp = extractMcpContent(toolInput);
-      if (mcp.command)
-        content.command = mcp.command;
-      if (mcp.url)
-        content.url = mcp.url;
-      if (mcp.file_path)
-        content.file_path = mcp.file_path;
-      break;
-    }
-  }
-  if (!content.url && signals.url_checks && signals.url_checks.length > 0) {
-    const firstUrl = signals.url_checks[0]?.url;
-    if (firstUrl)
-      content.url = firstUrl;
-  }
-  if (signals.package_checks && signals.package_checks.length > 0) {
-    const p = signals.package_checks[0];
-    if (p?.package_name)
-      content.package_name = p.package_name;
-    if (p?.package_version)
-      content.package_version = p.package_version;
-    if (p?.package_registry)
-      content.package_registry = p.package_registry;
-  }
-  applyFieldLimits(content);
-  return content;
+function amsiReportingData(amsiResult) {
+  const ruleName = AMSI_REPORTING_RULE_NAMES[amsiDetectionClass(amsiResult)];
+  return `${ruleName}:${Math.trunc(amsiResult).toString(16)}`;
 }
 
 // ../core/dist/extended-info.js
-var import_promises3 = require("node:fs/promises");
+var import_promises4 = require("node:fs/promises");
 var import_node_os3 = require("node:os");
-var import_node_path10 = require("node:path");
+var import_node_path11 = require("node:path");
 init_file_utils();
 init_types2();
 var EXTENDED_INFO_FILE_MAX_BYTES = 1024;
@@ -16401,8 +16631,8 @@ function sanitizeDocument(parsed, logger) {
   return out;
 }
 async function loadExtendedInfo(sageDirPath, logger = nullLogger) {
-  const sageDir = sageDirPath ?? (0, import_node_path10.join)((0, import_node_os3.homedir)(), ".sage");
-  const filePath = (0, import_node_path10.join)(sageDir, EXTENDED_INFO_FILENAME);
+  const sageDir = sageDirPath ?? (0, import_node_path11.join)((0, import_node_os3.homedir)(), ".sage");
+  const filePath = (0, import_node_path11.join)(sageDir, EXTENDED_INFO_FILENAME);
   const cached = cache.get(filePath);
   if (cached)
     return cached.value;
@@ -16413,7 +16643,7 @@ async function loadExtendedInfo(sageDirPath, logger = nullLogger) {
 async function loadExtendedInfoUncached(filePath, logger) {
   let size;
   try {
-    const info = await (0, import_promises3.stat)(filePath);
+    const info = await (0, import_promises4.stat)(filePath);
     if (!info.isFile()) {
       logger.debug(`extended-info: not a regular file at ${filePath}`);
       return null;
@@ -16501,13 +16731,13 @@ function mergeExtendedInfo(envelope, extendedInfo) {
 
 // ../core/dist/installation-id.js
 var import_node_crypto4 = require("node:crypto");
-var import_promises4 = require("node:fs/promises");
-var import_node_path11 = require("node:path");
+var import_promises5 = require("node:fs/promises");
+var import_node_path12 = require("node:path");
 init_config();
 init_file_utils();
 async function getInstallationId(sageDirPath) {
   const sageDir = sageDirPath ?? resolvePath("~/.sage");
-  const idPath = (0, import_node_path11.join)(sageDir, "installation-id");
+  const idPath = (0, import_node_path12.join)(sageDir, "installation-id");
   let fileExists = false;
   try {
     const existing = await getFileContent(idPath, "utf-8");
@@ -16519,8 +16749,8 @@ async function getInstallationId(sageDirPath) {
   }
   try {
     const id = (0, import_node_crypto4.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" });
+    await (0, import_promises5.mkdir)(sageDir, { recursive: true, mode: 448 });
+    await (0, import_promises5.writeFile)(idPath, id, { encoding: "utf-8", mode: 384, flag: fileExists ? "w" : "wx" });
     return id;
   } catch (err) {
     if (err.code === "EEXIST") {
@@ -16549,10 +16779,10 @@ function resolveTimeoutMs() {
   const ms = Math.floor(parsed * 1e3);
   return Math.min(ms, MAX_EFFECTIVE_TIMEOUT_MS);
 }
-async function sendCommunityIqDetection(args) {
+async function sendCommunityIqTelemetry(args) {
   const logger = args.logger ?? nullLogger;
   if (!args.communityIqEnabled) {
-    logger.debug("Community IQ disabled, skipping detection telemetry");
+    logger.debug("Community IQ disabled, skipping telemetry");
     return;
   }
   let iid;
@@ -16561,15 +16791,17 @@ async function sendCommunityIqDetection(args) {
   } catch {
   }
   if (!iid) {
-    logger.debug("Skipping detection telemetry: missing installation id");
+    logger.debug("Skipping telemetry: missing installation id");
     return;
   }
   const envelope = buildSageProxyEnvelope({
     iid,
     versionApp: VERSION,
     agentRuntime: args.agentRuntime ?? "unknown",
-    agentRuntimeVersion: args.agentRuntimeVersion ?? process.env.SAGE_AGENT_RUNTIME_VERSION ?? "unknown"
+    agentRuntimeVersion: args.agentRuntimeVersion ?? process.env.SAGE_AGENT_RUNTIME_VERSION ?? "unknown",
+    config: args.config
   });
+  const blocking = args.blocking ?? true;
   const payload = {
     ...envelope,
     block_event: {
@@ -16578,11 +16810,12 @@ async function sendCommunityIqDetection(args) {
       // canonicalize before calling `evaluateToolCall`, so no further
       // mapping is needed here.
       tool_type: args.toolName,
-      verdict: "deny",
-      user_action: "blocked",
+      verdict: blocking ? "deny" : "suspicious",
+      ...blocking ? { user_action: "blocked" } : {},
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       ...args.signals && Object.keys(args.signals).length > 0 ? { signals: args.signals } : {},
-      content: args.content ?? {}
+      content: args.content ?? {},
+      ...args.contentSnippet ? { content_snippet: args.contentSnippet } : {}
     },
     event_id: args.eventId,
     comment: ""
@@ -16590,20 +16823,21 @@ async function sendCommunityIqDetection(args) {
   const extendedInfo = await loadExtendedInfo(void 0, logger).catch(() => null);
   const enriched = mergeExtendedInfo(payload, extendedInfo);
   const timeoutMs = resolveTimeoutMs();
+  const endpoint = blocking ? "/v2/detection" : "/v2/heuristic";
   try {
-    const response = await fetch(resolveEndpoint("/v2/detection"), {
+    const response = await fetch(resolveEndpoint(endpoint), {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify(enriched),
       signal: AbortSignal.timeout(timeoutMs)
     });
     if (!response.ok) {
-      logger.warn("Detection telemetry send failed", {
+      logger.warn("Community IQ telemetry send failed", {
         eventId: args.eventId,
         status: response.status
       });
     } else {
-      logger.debug("Detection telemetry sent", {
+      logger.debug("Community IQ telemetry sent", {
         eventId: args.eventId,
         toolName: args.toolName,
         hookType: args.hookType ?? "PreToolUse"
@@ -16617,6 +16851,29 @@ async function sendCommunityIqDetection(args) {
   }
 }
 
+// ../core/dist/e2e-capture.js
+var import_node_path13 = require("node:path");
+var CAPTURE_MAX_BYTES = 10 * 1024 * 1024;
+var CAPTURE_MAX_FILES = 2;
+function captureEnabled() {
+  return !!process.env.SAGE_E2E_CAPTURE_DIR;
+}
+async function captureHookInput(event, raw, normalized, options = {}) {
+  const dir = process.env.SAGE_E2E_CAPTURE_DIR;
+  if (!dir)
+    return;
+  try {
+    const prefix = options.filePrefix ?? "";
+    const base = event === "PreToolUse" ? "pre-tool-use.jsonl" : "post-tool-use.jsonl";
+    await appendJsonlEntry({
+      path: (0, import_node_path13.join)(dir, `${prefix}${base}`),
+      max_bytes: CAPTURE_MAX_BYTES,
+      max_files: CAPTURE_MAX_FILES
+    }, { event, raw, normalized });
+  } catch {
+  }
+}
+
 // ../core/dist/policy.js
 init_types2();
 var SENSITIVITY_POLICY = {
@@ -16840,27 +17097,27 @@ init_config();
 
 // ../core/dist/exceptions.js
 var import_node_crypto5 = require("node:crypto");
-var import_node_path13 = require("node:path");
+var import_node_path15 = require("node:path");
 init_config();
 init_file_utils();
 
 // ../core/dist/trusted-domains.js
-var import_promises5 = require("node:fs/promises");
-var import_node_path12 = require("node:path");
+var import_promises6 = require("node:fs/promises");
+var import_node_path14 = require("node:path");
 var import_yaml = __toESM(require_dist(), 1);
 init_file_utils();
 init_types2();
 async function loadTrustedDomains(trustedDomainsDir, logger = nullLogger) {
   let files;
   try {
-    files = (await (0, import_promises5.readdir)(trustedDomainsDir)).filter((f) => f.endsWith(".yaml")).sort();
+    files = (await (0, import_promises6.readdir)(trustedDomainsDir)).filter((f) => f.endsWith(".yaml")).sort();
   } catch {
     logger.debug("Trusted domains directory does not exist", { path: trustedDomainsDir });
     return [];
   }
   const domains = [];
   for (const filename of files) {
-    const filePath = (0, import_node_path12.join)(trustedDomainsDir, filename);
+    const filePath = (0, import_node_path14.join)(trustedDomainsDir, filename);
     let content;
     try {
       content = await getFileContent(filePath);
@@ -17136,7 +17393,7 @@ function matchesDomain(pattern, url) {
 function normalizePatternPath(pattern) {
   const home = getHomeDir();
   const expanded = pattern.startsWith("~/") || pattern === "~" ? `${home}${pattern.slice(1)}` : pattern;
-  return (0, import_node_path13.normalize)(expanded);
+  return (0, import_node_path15.normalize)(expanded);
 }
 function matchesPath(pattern, filePath) {
   const hasWildcard = pattern.includes("*");
@@ -17147,7 +17404,7 @@ function matchesPath(pattern, filePath) {
   const normalizedPath = normalizePatternPath(filePath);
   if (normalizedPath === normalizedPattern)
     return true;
-  if (normalizedPath.startsWith(normalizedPattern + import_node_path13.sep))
+  if (normalizedPath.startsWith(normalizedPattern + import_node_path15.sep))
     return true;
   return false;
 }
@@ -17463,6 +17720,7 @@ var PackageChecker = class {
       if (pkg.name.startsWith("@")) {
         results.push({
           packageName: pkg.name,
+          packageVersion: pkg.version,
           registry: pkg.registry,
           verdict: "clean",
           confidence: 1,
@@ -17483,6 +17741,7 @@ var PackageChecker = class {
     } catch {
       return {
         packageName: pkg.name,
+        packageVersion: pkg.version,
         registry: pkg.registry,
         verdict: "unknown",
         confidence: 0.6,
@@ -17492,6 +17751,7 @@ var PackageChecker = class {
     if (metadata === null) {
       return {
         packageName: pkg.name,
+        packageVersion: pkg.version,
         registry: pkg.registry,
         verdict: "not_found",
         confidence: 0.95,
@@ -17501,6 +17761,7 @@ var PackageChecker = class {
     if (!metadata.requestedVersionFound && pkg.version) {
       return {
         packageName: pkg.name,
+        packageVersion: pkg.version,
         registry: pkg.registry,
         verdict: "not_found",
         confidence: 0.95,
@@ -17516,6 +17777,7 @@ var PackageChecker = class {
             const detections = fileResult.detectionNames.length > 0 ? fileResult.detectionNames.join(", ") : sev;
             return {
               packageName: pkg.name,
+              packageVersion: pkg.version,
               registry: pkg.registry,
               verdict: "malicious",
               confidence: 1,
@@ -17534,6 +17796,7 @@ var PackageChecker = class {
     if (ageDays !== void 0 && ageDays < SUSPICIOUS_AGE_DAYS) {
       return {
         packageName: pkg.name,
+        packageVersion: pkg.version,
         registry: pkg.registry,
         verdict: "suspicious_age",
         confidence: 0.6,
@@ -17543,6 +17806,7 @@ var PackageChecker = class {
     }
     return {
       packageName: pkg.name,
+      packageVersion: pkg.version,
       registry: pkg.registry,
       verdict: "clean",
       confidence: 1,
@@ -17927,7 +18191,7 @@ function extractFromRequirementsTxt(content) {
 }
 
 // ../core/dist/statusline.js
-var import_node_path14 = require("node:path");
+var import_node_path16 = require("node:path");
 init_config();
 init_file_utils();
 var STATUS_PREFIX = "statusline-";
@@ -17936,15 +18200,17 @@ function sanitizeSessionId(sessionId) {
   return sessionId.replace(/[^a-zA-Z0-9-]/g, "_");
 }
 function statusFilePath(sessionId) {
-  return (0, import_node_path14.join)(resolvePath(SAGE_DIR), `${STATUS_PREFIX}${sanitizeSessionId(sessionId)}${STATUS_SUFFIX}`);
+  return (0, import_node_path16.join)(resolvePath(SAGE_DIR), `${STATUS_PREFIX}${sanitizeSessionId(sessionId)}${STATUS_SUFFIX}`);
 }
 function emptyStatus() {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
   return {
     denied: 0,
     flagged: 0,
     lastCategory: null,
     lastReason: null,
-    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    updatedAt: now,
+    startedAt: now
   };
 }
 async function readStatus(sessionId) {
@@ -17969,13 +18235,15 @@ async function updateSessionStatus(sessionId, verdict) {
 }
 
 // ../core/dist/threat-loader.js
-var import_promises6 = require("node:fs/promises");
-var import_node_path15 = require("node:path");
+var import_promises7 = require("node:fs/promises");
+var import_node_path17 = require("node:path");
 var import_yaml2 = __toESM(require_dist(), 1);
 init_file_utils();
 init_types2();
 var REQUIRED_FIELDS = /* @__PURE__ */ new Set([
   "id",
+  "version",
+  "detection_name",
   "category",
   "severity",
   "confidence",
@@ -17983,6 +18251,37 @@ var REQUIRED_FIELDS = /* @__PURE__ */ new Set([
   "match_on",
   "title"
 ]);
+var MACRO_FILENAME = "_macros.yaml";
+var MAX_MACRO_PASSES = 5;
+var MACRO_REF = /\{\{([A-Z0-9_]+)\}\}/g;
+function expandMacros(pattern, macros) {
+  let expanded = pattern;
+  for (let pass = 0; pass <= MAX_MACRO_PASSES; pass++) {
+    if (!expanded.includes("{{"))
+      return expanded;
+    if (pass === MAX_MACRO_PASSES) {
+      throw new Error(`macro nesting exceeds ${MAX_MACRO_PASSES} passes`);
+    }
+    expanded = expanded.replace(MACRO_REF, (_match, name) => {
+      const value = macros[name];
+      if (value === void 0)
+        throw new Error(`undefined macro {{${name}}}`);
+      return value;
+    });
+  }
+  return expanded;
+}
+function readMacros(filename, data, logger) {
+  const macros = {};
+  for (const [name, value] of Object.entries(data)) {
+    if (typeof value !== "string") {
+      logger.warn(`Skipping macro ${name} in ${filename}: not a string`);
+      continue;
+    }
+    macros[name] = value;
+  }
+  return macros;
+}
 function parseExpiresAt(value) {
   if (value == null)
     return null;
@@ -18003,16 +18302,17 @@ async function loadThreats(threatDir, logger = nullLogger) {
   const threats = [];
   let files;
   try {
-    files = (await (0, import_promises6.readdir)(threatDir)).filter((f) => f.endsWith(".yaml")).sort();
+    files = (await (0, import_promises7.readdir)(threatDir)).filter((f) => f.endsWith(".yaml")).sort();
   } catch {
     logger.warn("Threat directory does not exist or is unreadable", { path: threatDir });
     return threats;
   }
+  const ruleFiles = [];
+  let macros = {};
   for (const filename of files) {
-    const filePath = (0, import_node_path15.join)(threatDir, filename);
     let content;
     try {
-      content = await getFileContent(filePath);
+      content = await getFileContent((0, import_node_path17.join)(threatDir, filename));
     } catch (e) {
       logger.warn(`Failed to read ${filename}`, { error: String(e) });
       continue;
@@ -18024,10 +18324,21 @@ async function loadThreats(threatDir, logger = nullLogger) {
       logger.warn(`Failed to parse ${filename}`, { error: String(e) });
       continue;
     }
+    if (filename === MACRO_FILENAME) {
+      if (typeof data !== "object" || data === null || Array.isArray(data)) {
+        logger.warn(`Expected mapping in ${filename}, got ${Array.isArray(data) ? "list" : typeof data}`);
+        continue;
+      }
+      macros = readMacros(filename, data, logger);
+      continue;
+    }
     if (!Array.isArray(data)) {
       logger.warn(`Expected list in ${filename}, got ${typeof data}`);
       continue;
     }
+    ruleFiles.push({ filename, data });
+  }
+  for (const { filename, data } of ruleFiles) {
     for (const entry of data) {
       if (typeof entry !== "object" || entry === null) {
         logger.warn(`Skipping non-object entry in ${filename}`);
@@ -18044,10 +18355,12 @@ async function loadThreats(threatDir, logger = nullLogger) {
         continue;
       if (isExpired(record))
         continue;
+      let pattern;
       let compiledPattern;
       try {
+        pattern = expandMacros(record.pattern, macros);
         const flags2 = record.case_insensitive === true ? "i" : "";
-        compiledPattern = new RegExp(record.pattern, flags2);
+        compiledPattern = new RegExp(pattern, flags2);
       } catch (e) {
         logger.warn(`Skipping threat ${record.id}: invalid regex pattern`, {
           error: String(e)
@@ -18065,13 +18378,28 @@ async function loadThreats(threatDir, logger = nullLogger) {
         });
         continue;
       }
+      const version = record.version;
+      if (typeof version !== "number" || !Number.isInteger(version) || version <= 0) {
+        logger.warn(`Skipping threat ${record.id}: invalid version`, {
+          version
+        });
+        continue;
+      }
+      const detectionName = record.detection_name;
+      if (typeof detectionName !== "string" || !isCanonicalDetectionName(detectionName)) {
+        logger.warn(`Skipping threat ${record.id}: invalid detection_name`, {
+          detectionName
+        });
+        continue;
+      }
       threats.push({
         id: record.id,
-        version: typeof record.version === "number" ? record.version : void 0,
+        version,
+        detectionName,
         category: record.category,
         severity: record.severity,
         confidence,
-        pattern: record.pattern,
+        pattern,
         compiledPattern,
         matchOn,
         title: record.title,
@@ -18089,6 +18417,29 @@ async function loadThreats(threatDir, logger = nullLogger) {
 init_types2();
 var AMSI_CONTENT_SNIPPET_MAX = 200;
 var AMSI_CONTENT_NAME_MAX = 256;
+var HEURISTIC_PI_CONTENT_SNIPPET_MAX = 200;
+function buildHeuristicSignal(match) {
+  return {
+    detection_name: formatReportingDetectionName(match.threat.detectionName, "heuristics", `${match.threat.id}:${match.threat.version}`),
+    rule_id: match.threat.id,
+    rule_version: match.threat.version
+  };
+}
+function resolvePiContentSnippet(piResults, heuristicMatches) {
+  let highestRiskResult;
+  for (const result of piResults) {
+    if (result.risk >= DEFAULT_PI_MEDIUM_RISK_THRESHOLD && result.contentSnippet && (!highestRiskResult || result.risk > highestRiskResult.risk)) {
+      highestRiskResult = result;
+    }
+  }
+  if (highestRiskResult?.contentSnippet)
+    return scrubHomePath(highestRiskResult.contentSnippet);
+  const heuristicMatch = heuristicMatches.find((match) => match.threat.category === "prompt_injection");
+  if (!heuristicMatch)
+    return void 0;
+  const snippet = safeTruncate(scrubHomePath(heuristicMatch.matchValue), HEURISTIC_PI_CONTENT_SNIPPET_MAX);
+  return snippet || void 0;
+}
 function scrubAmsiContentName(contentName) {
   const colon = contentName.indexOf(":");
   if (colon < 0)
@@ -18098,16 +18449,10 @@ function scrubAmsiContentName(contentName) {
   return `${head}${scrubHomePath(tail)}`;
 }
 function buildAmsiSignal(r) {
-  const detectionName = r.amsiResult >= 32768 ? "AMSI|DETECTED" : r.amsiResult >= 16384 ? "AMSI|BLOCKED_BY_ADMIN" : (
-    // Defensive: callers should filter these out via `isDetected || isBlockedByAdmin`,
-    // but if a non-detected/non-blocked result still reaches here we emit a
-    // meaningful label rather than silently dropping the entry.
-    "AMSI|UNKNOWN"
-  );
   const contentName = safeTruncate(scrubAmsiContentName(r.contentName), AMSI_CONTENT_NAME_MAX);
   const snippet = r.content ? safeTruncate(scrubHomePath(r.content), AMSI_CONTENT_SNIPPET_MAX) : "";
   return {
-    detection_name: detectionName,
+    detection_name: formatReportingDetectionName(amsiDetectionName(r.amsiResult), "amsi", amsiReportingData(r.amsiResult)),
     content_name: contentName,
     amsi_result: r.amsiResult,
     ...snippet ? { content_snippet: snippet } : {}
@@ -18179,7 +18524,7 @@ async function evaluateToolCall(request, context) {
         severity: "critical",
         source: "exception",
         artifacts: [denyMatch.artifact.value],
-        matchedThreatId: null,
+        matchedThreatId: denyMatch.rule.id,
         reasons: [
           `Deny exception: ${denyMatch.rule.match} pattern '${denyMatch.rule.pattern}'${denyMatch.rule.reason ? ` \u2014 ${denyMatch.rule.reason}` : ""}`
         ]
@@ -18349,6 +18694,12 @@ async function evaluateToolCall(request, context) {
               if (result) {
                 allPiResults.push(result);
               }
+            } else {
+              logger.info("PI model inference skipped", {
+                context: `WebFetch:${url}`,
+                reason: "content_not_scannable",
+                contentType: fetched.contentType ?? "unknown"
+              });
             }
           }
         }
@@ -18365,8 +18716,8 @@ async function evaluateToolCall(request, context) {
       amsiCheckResults: amsiCheckResults.length > 0 ? amsiCheckResults : void 0,
       piCheckResults: allPiResults,
       piThresholds: {
-        highRisk: config2.pi_check.high_risk_threshold,
-        mediumRisk: config2.pi_check.medium_risk_threshold
+        highRisk: DEFAULT_PI_HIGH_RISK_THRESHOLD,
+        mediumRisk: DEFAULT_PI_MEDIUM_RISK_THRESHOLD
       }
     });
   } else {
@@ -18394,24 +18745,9 @@ async function evaluateToolCall(request, context) {
     }
   }
   await cacheUrlResults(urlCheckResults, cache2);
-  function formatPackageDetectionName(p) {
-    const base = `PKG|${p.verdict}|registry=${p.registry}|name=${p.packageName}`;
-    if (p.verdict === "suspicious_age") {
-      const ageDays = typeof p.ageDays === "number" ? Math.floor(p.ageDays) : void 0;
-      return ageDays !== void 0 ? `${base}|age_days=${ageDays}` : base;
-    }
-    if (p.verdict === "malicious") {
-      const det = (p.fileDetectionNames ?? []).filter((d) => typeof d === "string" && d.length > 0);
-      return det.length > 0 ? `${base}|det=${det.join(",")}` : base;
-    }
-    return base;
-  }
   const auditSignals = {};
   if (heuristicMatches.length > 0) {
-    auditSignals.heuristics = heuristicMatches.map((m) => ({
-      rule_id: m.threat.id,
-      rule_version: typeof m.threat.version === "number" ? m.threat.version : void 0
-    }));
+    auditSignals.heuristics = heuristicMatches.map(buildHeuristicSignal);
   }
   if (urlCheckResults.length > 0) {
     const relevant = urlCheckResults.filter((r) => r.isMalicious);
@@ -18442,9 +18778,9 @@ async function evaluateToolCall(request, context) {
     const relevant = packageCheckResults.filter((p) => p.verdict !== "clean");
     if (relevant.length > 0) {
       auditSignals.package_checks = relevant.map((p) => ({
-        detection_name: formatPackageDetectionName(p),
+        detection_name: formatReportingDetectionName(packageDetectionName(p.verdict), "package", p.packageVersion ? `${p.packageName}:${p.packageVersion}` : p.packageName),
         package_name: p.packageName,
-        package_version: void 0,
+        package_version: p.packageVersion,
         package_registry: p.registry
       }));
     }
@@ -18457,8 +18793,9 @@ async function evaluateToolCall(request, context) {
     }
   }
   if (allPiResults.length > 0) {
-    const piSnippetFloor = config2.pi_check.medium_risk_threshold;
+    const piSnippetFloor = DEFAULT_PI_MEDIUM_RISK_THRESHOLD;
     auditSignals.pi_checks = allPiResults.map((r) => ({
+      detection_name: formatReportingDetectionName(PI_DETECTION_NAME, "ml", `${r.modelId}:${MODEL_SCHEMA_VERSION}`),
       risk: r.risk,
       model_id: r.modelId,
       content_name: r.contentName,
@@ -18472,6 +18809,7 @@ async function evaluateToolCall(request, context) {
     }
   }
   const resolvedSignals = Object.keys(auditSignals).length > 0 ? auditSignals : void 0;
+  const contentSnippet = resolvePiContentSnippet(allPiResults, heuristicMatches);
   const builtContent = buildContentSnapshot(request.toolName, request.toolInput, request.artifacts, auditSignals);
   const resolvedContent = Object.keys(builtContent).length > 0 ? builtContent : void 0;
   try {
@@ -18485,28 +18823,37 @@ async function evaluateToolCall(request, context) {
       hookType: request.hookType,
       signals: resolvedSignals,
       content: resolvedContent,
+      contentSnippet,
       eventId,
       toolUseId: request.toolUseId
     });
   } catch (error) {
     logger.debug("Audit verdict logging failed open", { error: String(error) });
   }
-  if (verdict.decision === "deny") {
+  const submitTelemetry = async (blocking) => {
     try {
-      await sendCommunityIqDetection({
+      await sendCommunityIqTelemetry({
         eventId,
         agentRuntime: request.agentRuntime,
         agentRuntimeVersion: request.agentRuntimeVersion,
         hookType: request.hookType,
         toolName: request.toolName,
         content: resolvedContent,
+        contentSnippet,
         signals: resolvedSignals,
         communityIqEnabled: config2.community_iq,
+        config: config2,
+        blocking,
         logger
       });
     } catch (error) {
-      logger.debug("Detection telemetry failed open", { error: String(error) });
+      logger.debug("Community IQ telemetry failed open", { error: String(error) });
     }
+  };
+  if (verdict.decision === "deny") {
+    await submitTelemetry(true);
+  } else if (allPiResults.some((r) => r.risk >= DEFAULT_PI_TELEMETRY_THRESHOLD && r.risk < DEFAULT_PI_HIGH_RISK_THRESHOLD)) {
+    await submitTelemetry(false);
   }
   if (verdict.decision !== "allow") {
     try {
@@ -18515,7 +18862,7 @@ async function evaluateToolCall(request, context) {
       logger.debug("Session status update failed open", { error: String(error) });
     }
   }
-  const piWarnings = allPiResults.filter((r) => r.risk >= config2.pi_check.medium_risk_threshold && r.risk < config2.pi_check.high_risk_threshold);
+  const piWarnings = allPiResults.filter((r) => r.risk >= DEFAULT_PI_MEDIUM_RISK_THRESHOLD && r.risk < DEFAULT_PI_HIGH_RISK_THRESHOLD);
   if (piWarnings.length > 0 && config2.sensitivity !== "relaxed")
     verdict.piWarnings = piWarnings;
   logEvaluationCompleted(verdict);
@@ -18618,6 +18965,7 @@ async function checkPackages(request, config2, cache2, logger) {
       }
       results.push({
         packageName: pkg.name,
+        packageVersion: pkg.version,
         registry: pkg.registry,
         verdict: rawVerdict,
         confidence: rawConf,
@@ -18657,7 +19005,7 @@ function createPiProvider(config2, _context, logger) {
   return new BundledPiProvider({
     modelPath: config2.pi_check.model_path,
     maxContentLength: config2.pi_check.max_content_length,
-    mediumRiskThreshold: config2.pi_check.medium_risk_threshold,
+    mediumRiskThreshold: DEFAULT_PI_MEDIUM_RISK_THRESHOLD,
     logger
   });
 }
@@ -18682,6 +19030,19 @@ function kv(key, value) {
 function separatorLine(headerLength) {
   return "\u2501".repeat(headerLength);
 }
+function ruleLabel(verdict) {
+  if (!verdict.matchedThreatId)
+    return null;
+  return verdict.source === "exception" ? `${verdict.matchedThreatId} (your exception rule)` : verdict.matchedThreatId;
+}
+function remediationHint(verdict) {
+  if (verdict.source === "exception") {
+    const id = verdict.matchedThreatId ? ` (id ${verdict.matchedThreatId})` : "";
+    return `This block comes from your own rule in ~/.sage/exceptions.json${id} \u2014 edit or remove it there.`;
+  }
+  const rule = verdict.matchedThreatId ? ` (rule ${verdict.matchedThreatId})` : "";
+  return `If this is a false positive, use the sage_report_false_positive MCP tool to report it${rule}.`;
+}
 function formatUpdateNotice(result) {
   return `\u2B06\uFE0F  Update available: v${result.currentVersion} \u2192 v${result.latestVersion} (https://github.com/gendigitalinc/sage)`;
 }
@@ -18828,15 +19189,225 @@ function summarizeArtifacts(artifacts) {
 function formatDenyMessage(verdict, branding2 = defaultBranding) {
   const maxReasons = 5;
   const reasons = verdict.reasons.length > 0 ? verdict.reasons.slice(0, maxReasons).join("; ") + (verdict.reasons.length > maxReasons ? `; ... and ${verdict.reasons.length - maxReasons} more` : "") : verdict.category;
+  const rule = ruleLabel(verdict);
   return [
     `${branding2.name} blocked this action.`,
     `Severity: ${verdict.severity}`,
     `Category: ${verdict.category}`,
+    ...rule ? [`Rule: ${rule}`] : [],
     `Reason: ${reasons}`,
-    `If this is a false positive, use the sage_report_false_positive MCP tool to report it.`
+    remediationHint(verdict)
   ].join("\n");
 }
 
+// ../core/dist/install-state.js
+var import_node_path18 = require("node:path");
+init_config();
+init_file_utils();
+
+// ../core/dist/notices.js
+init_config();
+var SKILL_UPLOAD_NOTICE = {
+  id: "skill_upload_v1",
+  body: () => [
+    "unknown skills \u2014 each skill's SKILL.md and every supporting file in its",
+    "folder \u2014 will be uploaded and checked against potential malicious artifacts",
+    "starting next session. To keep skill content on this machine, set",
+    '"skill_check": { "upload_enabled": false } in ~/.sage/config.json.'
+  ],
+  // Suppressed once the user has explicitly set upload_enabled either way: an
+  // explicit choice needs no consent prompt (the rollout obeys it directly).
+  isEligible: async ({ configPath, logger }) => !(await readExplicitSkillUploadEnabled(configPath, logger)).present
+};
+var NOTICES = {
+  [SKILL_UPLOAD_NOTICE.id]: SKILL_UPLOAD_NOTICE
+};
+var INFO_ICON = "\u2139\uFE0F";
+var CONTINUATION_INDENT = "   ";
+function formatNotice(notice, branding2 = defaultBranding) {
+  const [first = "", ...rest] = notice.body(branding2);
+  const head = `${INFO_ICON}  ${branding2.name}: ${first}`;
+  return [head, ...rest.map((line) => `${CONTINUATION_INDENT}${line}`)].join("\n");
+}
+function formatNoticeById(id, branding2 = defaultBranding) {
+  const notice = NOTICES[id];
+  return notice ? formatNotice(notice, branding2) : "";
+}
+
+// ../core/dist/install-state.js
+init_types2();
+var INSTALL_STATE_SCHEMA_VERSION = 1;
+var SKILL_UPLOAD_NOTICE_ID = SKILL_UPLOAD_NOTICE.id;
+function defaultStatePath(sageDirPath) {
+  return (0, import_node_path18.join)(sageDirPath ?? resolvePath(SAGE_DIR), "install-state.json");
+}
+function emptyState() {
+  return { schemaVersion: INSTALL_STATE_SCHEMA_VERSION, notices: {} };
+}
+async function loadInstallState(sageDirPath, logger = nullLogger) {
+  let raw;
+  try {
+    raw = await getFileContent(defaultStatePath(sageDirPath));
+  } catch {
+    return emptyState();
+  }
+  try {
+    const data = JSON.parse(raw);
+    const rawNotices = data.notices ?? {};
+    const notices = {};
+    for (const [id, rec] of Object.entries(rawNotices)) {
+      notices[id] = {
+        noticed: rec.noticed === true,
+        version: typeof rec.version === "string" ? rec.version : void 0
+      };
+    }
+    return {
+      schemaVersion: typeof data.schema_version === "number" ? data.schema_version : INSTALL_STATE_SCHEMA_VERSION,
+      lastRunVersion: typeof data.last_run_version === "string" ? data.last_run_version : void 0,
+      notices
+    };
+  } catch (e) {
+    logger.warn("Failed to parse install state; treating as fresh", { error: String(e) });
+    return emptyState();
+  }
+}
+async function saveInstallState(state, sageDirPath, logger = nullLogger) {
+  try {
+    const data = {
+      schema_version: state.schemaVersion,
+      last_run_version: state.lastRunVersion,
+      notices: Object.fromEntries(Object.entries(state.notices).map(([id, rec]) => [
+        id,
+        { noticed: rec.noticed, version: rec.version }
+      ]))
+    };
+    await atomicWriteJson(defaultStatePath(sageDirPath), data);
+  } catch (e) {
+    logger.warn("Failed to save install state", { error: String(e) });
+  }
+}
+function decideSkillUploadRollout(state, opts = {}) {
+  const versionChanged = opts.version !== void 0 && state.lastRunVersion !== opts.version;
+  const withVersion = () => ({ ...state, lastRunVersion: opts.version });
+  if (opts.explicitConfig) {
+    return {
+      uploadActive: opts.explicitValue === true,
+      showNotice: false,
+      nextState: versionChanged ? withVersion() : null
+    };
+  }
+  const notice = state.notices[SKILL_UPLOAD_NOTICE_ID];
+  if (notice?.noticed === true) {
+    return {
+      uploadActive: true,
+      showNotice: false,
+      nextState: versionChanged ? withVersion() : null
+    };
+  }
+  const nextState = {
+    ...state,
+    lastRunVersion: opts.version ?? state.lastRunVersion,
+    notices: {
+      ...state.notices,
+      [SKILL_UPLOAD_NOTICE_ID]: { noticed: true, version: opts.version }
+    }
+  };
+  return { uploadActive: false, showNotice: true, nextState };
+}
+var processRollout;
+async function resolveSkillUploadRollout(args) {
+  const commitNotice = args.commitNotice ?? true;
+  const logger = args.logger ?? nullLogger;
+  let explicit;
+  try {
+    explicit = await readExplicitSkillUploadEnabled(args.configPath, logger);
+  } catch {
+    explicit = { present: false, value: false };
+  }
+  if (explicit.present) {
+    const resolved = {
+      uploadActive: explicit.value === true,
+      showNotice: false,
+      deferUnknownSkills: false
+    };
+    logger.debug("Skill-upload rollout resolved", {
+      explicitConfig: true,
+      explicitValue: explicit.value,
+      uploadActive: resolved.uploadActive,
+      showNotice: false,
+      deferUnknownSkills: false,
+      commitNotice,
+      statePersisted: false,
+      version: args.version
+    });
+    return resolved;
+  }
+  if (processRollout)
+    return processRollout;
+  try {
+    const state = await loadInstallState(args.sageDirPath, logger);
+    const decision = decideSkillUploadRollout(state, { version: args.version });
+    if (commitNotice) {
+      if (decision.nextState) {
+        await saveInstallState(decision.nextState, args.sageDirPath, logger);
+      }
+      processRollout = {
+        uploadActive: decision.uploadActive,
+        showNotice: decision.showNotice,
+        deferUnknownSkills: decision.showNotice
+      };
+    } else {
+      processRollout = {
+        uploadActive: decision.uploadActive,
+        showNotice: false,
+        deferUnknownSkills: decision.showNotice
+      };
+    }
+    logger.debug("Skill-upload rollout resolved", {
+      explicitConfig: false,
+      uploadActive: processRollout.uploadActive,
+      showNotice: processRollout.showNotice,
+      deferUnknownSkills: processRollout.deferUnknownSkills,
+      commitNotice,
+      statePersisted: commitNotice && decision.nextState !== null,
+      version: args.version
+    });
+  } catch (e) {
+    logger.warn("Skill-upload rollout resolution failed; suppressing upload", {
+      error: String(e)
+    });
+    processRollout = { uploadActive: false, showNotice: commitNotice, deferUnknownSkills: true };
+  }
+  return processRollout;
+}
+async function takePendingNotices(args) {
+  const logger = args.logger ?? nullLogger;
+  try {
+    const state = await loadInstallState(args.sageDirPath, logger);
+    const toShow = [];
+    for (const notice of Object.values(NOTICES)) {
+      if (state.notices[notice.id]?.noticed === true)
+        continue;
+      const eligible = notice.isEligible ? await notice.isEligible({ configPath: args.configPath, logger }) : true;
+      if (eligible)
+        toShow.push(notice.id);
+    }
+    if (toShow.length === 0)
+      return [];
+    const nextNotices = { ...state.notices };
+    for (const id of toShow)
+      nextNotices[id] = { noticed: true };
+    await saveInstallState({ ...state, notices: nextNotices }, args.sageDirPath, logger);
+    logger.debug("Pending notices taken for delivery", { noticeIds: toShow });
+    return toShow;
+  } catch (e) {
+    logger.warn("takePendingNotices failed; showing no notices this turn", {
+      error: String(e)
+    });
+    return [];
+  }
+}
+
 // ../core/dist/model-download.js
 init_types2();
 
@@ -18908,8 +19479,8 @@ function createOperationalLogger(config2, runtime) {
       try {
         const result = await Promise.race([
           Promise.allSettled([...pendingWrites]).then(() => "drained"),
-          new Promise((resolve9) => {
-            timeout = setTimeout(() => resolve9("timeout"), remainingMs);
+          new Promise((resolve10) => {
+            timeout = setTimeout(() => resolve10("timeout"), remainingMs);
             timeout.unref?.();
           })
         ]);
@@ -18958,13 +19529,14 @@ function createOperationalLogger(config2, runtime) {
 
 // ../core/dist/plugin-scan-cache.js
 var import_node_crypto7 = require("node:crypto");
-var import_promises7 = require("node:fs/promises");
-var import_node_path16 = require("node:path");
+var import_promises8 = require("node:fs/promises");
+var import_node_path19 = require("node:path");
+init_config();
 init_file_utils();
 init_types2();
-var DEFAULT_CACHE_PATH = (0, import_node_path16.join)(getHomeDir(), ".sage", "plugin_scan_cache.json");
-var CACHE_TTL_DAYS = 1;
-var SCHEMA_VERSION = 3;
+var DEFAULT_CACHE_PATH = (0, import_node_path19.join)(getHomeDir(), ".sage", "plugin_scan_cache.json");
+var DEFAULT_CACHE_TTL_MS = MS_PER_DAY;
+var SCHEMA_VERSION = 5;
 function cacheKey(pluginKey, version, lastUpdated) {
   return `${pluginKey}:${version}:${lastUpdated}`;
 }
@@ -18975,13 +19547,13 @@ async function computeConfigHash(sageVersion, ...dirs) {
   for (const dir of dirs) {
     let files;
     try {
-      files = (await (0, import_promises7.readdir)(dir)).filter((f) => f.endsWith(".yaml")).sort();
+      files = (await (0, import_promises8.readdir)(dir)).filter((f) => f.endsWith(".yaml")).sort();
     } catch {
       continue;
     }
     for (const file of files) {
       try {
-        const content = await getFileContent((0, import_node_path16.join)(dir, file));
+        const content = await getFileContent((0, import_node_path19.join)(dir, file));
         h.update(content);
       } catch {
       }
@@ -19050,7 +19622,7 @@ async function saveScanCache(cache2, cachePath = DEFAULT_CACHE_PATH, logger = nu
     logger.warn(`Failed to save scan cache to ${cachePath}`, { error: String(e) });
   }
 }
-function isCached(cache2, pluginKey, version, lastUpdated) {
+function isCached(cache2, pluginKey, version, lastUpdated, ttlMs = DEFAULT_CACHE_TTL_MS) {
   const key = cacheKey(pluginKey, version, lastUpdated);
   const entry = cache2.entries[key];
   if (!entry)
@@ -19058,13 +19630,13 @@ function isCached(cache2, pluginKey, version, lastUpdated) {
   try {
     const scannedAt = new Date(entry.scannedAt);
     const age = Date.now() - scannedAt.getTime();
-    return age < CACHE_TTL_DAYS * 24 * 60 * 60 * 1e3;
+    return age < ttlMs;
   } catch {
     return false;
   }
 }
-function getCached(cache2, pluginKey, version, lastUpdated) {
-  if (!isCached(cache2, pluginKey, version, lastUpdated))
+function getCached(cache2, pluginKey, version, lastUpdated, ttlMs = DEFAULT_CACHE_TTL_MS) {
+  if (!isCached(cache2, pluginKey, version, lastUpdated, ttlMs))
     return null;
   const key = cacheKey(pluginKey, version, lastUpdated);
   return cache2.entries[key] ?? null;
@@ -19081,18 +19653,21 @@ function storeResult(cache2, pluginKey, version, lastUpdated, findings) {
 
 // ../core/dist/plugin-scanner.js
 var import_node_crypto9 = require("node:crypto");
-var import_promises9 = require("node:fs/promises");
-var import_node_path18 = require("node:path");
+var import_promises11 = require("node:fs/promises");
+var import_node_path23 = require("node:path");
 init_config();
 init_file_utils();
 
 // ../core/dist/skill-id.js
 var import_node_crypto8 = require("node:crypto");
-var import_promises8 = require("node:fs/promises");
-var import_node_path17 = require("node:path");
+var import_promises9 = require("node:fs/promises");
+var import_node_path20 = require("node:path");
 var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "__pycache__"]);
+var MAX_SKILL_BYTES = 50 * 1024 * 1024;
+var SkillTooLargeError = class extends Error {
+};
 function isContained(childReal, rootReal) {
-  return childReal === rootReal || childReal.startsWith(`${rootReal}${import_node_path17.sep}`);
+  return childReal === rootReal || childReal.startsWith(`${rootReal}${import_node_path20.sep}`);
 }
 function normalizePath(p) {
   let out = p.replace(/\\/g, "/").normalize("NFC");
@@ -19102,47 +19677,51 @@ function normalizePath(p) {
   }
   return out;
 }
-async function entriesFromDirectory(dirPath) {
-  const absDir = (0, import_node_path17.resolve)(dirPath);
-  const rootReal = await (0, import_promises8.realpath)(absDir);
+async function entriesFromDirectory(dirPath, maxBytes = Number.POSITIVE_INFINITY) {
+  const absDir = (0, import_node_path20.resolve)(dirPath);
+  const rootReal = await (0, import_promises9.realpath)(absDir);
   const entries = [];
   const visited = /* @__PURE__ */ new Set();
+  let total = 0;
   async function walk(currentPath) {
-    const real = await (0, import_promises8.realpath)(currentPath);
+    const real = await (0, import_promises9.realpath)(currentPath);
     if (visited.has(real))
       return;
     if (!isContained(real, rootReal))
       return;
     visited.add(real);
-    const items = await (0, import_promises8.readdir)(currentPath);
+    const items = await (0, import_promises9.readdir)(currentPath);
     const dirs = [];
     const files = [];
     for (const item of items) {
-      const fullPath = (0, import_node_path17.join)(currentPath, item);
-      const st = await (0, import_promises8.stat)(fullPath);
+      const fullPath = (0, import_node_path20.join)(currentPath, item);
+      const st = await (0, import_promises9.stat)(fullPath);
       if (st.isDirectory())
         dirs.push(item);
       else if (st.isFile())
-        files.push(item);
+        files.push({ name: item, size: st.size });
     }
     dirs.sort();
-    files.sort();
+    files.sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
     for (const d of dirs) {
-      const fullPath = (0, import_node_path17.join)(currentPath, d);
-      const relPath = (0, import_node_path17.relative)(absDir, fullPath).replace(/\\/g, "/");
+      const fullPath = (0, import_node_path20.join)(currentPath, d);
+      const relPath = (0, import_node_path20.relative)(absDir, fullPath).replace(/\\/g, "/");
       entries.push({ entryPath: relPath, isDir: true, content: Buffer.alloc(0) });
       await walk(fullPath);
     }
     for (const f of files) {
-      const fullPath = (0, import_node_path17.join)(currentPath, f);
-      const fileReal = await (0, import_promises8.realpath)(fullPath);
+      const fullPath = (0, import_node_path20.join)(currentPath, f.name);
+      const fileReal = await (0, import_promises9.realpath)(fullPath);
       if (!isContained(fileReal, rootReal))
         continue;
-      const relPath = (0, import_node_path17.relative)(absDir, fullPath).replace(/\\/g, "/");
+      total += f.size;
+      if (total > maxBytes)
+        throw new SkillTooLargeError();
+      const relPath = (0, import_node_path20.relative)(absDir, fullPath).replace(/\\/g, "/");
       entries.push({
         entryPath: relPath,
         isDir: false,
-        content: await (0, import_promises8.readFile)(fullPath)
+        content: await (0, import_promises9.readFile)(fullPath)
       });
     }
   }
@@ -19179,77 +19758,347 @@ function computeSkillId(entries) {
   }
   return { skillId: skillHasher.digest("hex"), fileHashes };
 }
-async function findSkillPackages(rootDir) {
+async function findSkillPackagesWithMtime(rootDir) {
   const found = [];
   let rootReal;
   try {
-    const rootStat = await (0, import_promises8.stat)(rootDir);
-    if (!rootStat.isDirectory())
-      return found;
-    rootReal = await (0, import_promises8.realpath)((0, import_node_path17.resolve)(rootDir));
+    rootReal = await (0, import_promises9.realpath)((0, import_node_path20.resolve)(rootDir));
   } catch {
     return found;
   }
   const visited = /* @__PURE__ */ new Set();
-  async function walk(dir) {
+  async function walk(currentPath) {
     let real;
     try {
-      real = await (0, import_promises8.realpath)(dir);
+      real = await (0, import_promises9.realpath)(currentPath);
     } catch {
-      return;
+      return 0;
     }
     if (visited.has(real))
-      return;
+      return 0;
     if (!isContained(real, rootReal))
-      return;
+      return 0;
     visited.add(real);
+    let st;
+    try {
+      st = await (0, import_promises9.stat)(currentPath);
+    } catch {
+      return 0;
+    }
+    let subtreeMax = st.mtimeMs;
+    if (!st.isDirectory())
+      return subtreeMax;
     let items;
     try {
-      items = await (0, import_promises8.readdir)(dir);
+      items = await (0, import_promises9.readdir)(currentPath);
     } catch {
-      return;
+      return subtreeMax;
     }
     items.sort();
+    let entry;
     if (items.includes("SKILL.md")) {
       try {
-        const st = await (0, import_promises8.stat)((0, import_node_path17.join)(dir, "SKILL.md"));
-        if (st.isFile())
-          found.push(dir);
+        if ((await (0, import_promises9.stat)((0, import_node_path20.join)(currentPath, "SKILL.md"))).isFile()) {
+          entry = { folder: currentPath, newestMtimeMs: 0 };
+          found.push(entry);
+        }
       } catch {
       }
     }
     for (const item of items) {
       if (SKIP_DIRS.has(item))
         continue;
-      const fullPath = (0, import_node_path17.join)(dir, item);
-      let st;
-      try {
-        st = await (0, import_promises8.stat)(fullPath);
-      } catch {
-        continue;
-      }
-      if (st.isDirectory()) {
-        await walk(fullPath);
-      }
+      const childMax = await walk((0, import_node_path20.join)(currentPath, item));
+      if (childMax > subtreeMax)
+        subtreeMax = childMax;
     }
+    if (entry)
+      entry.newestMtimeMs = subtreeMax;
+    return subtreeMax;
   }
-  await walk((0, import_node_path17.resolve)(rootDir));
+  await walk((0, import_node_path20.resolve)(rootDir));
   return found;
 }
-async function computeSkillIdsForRoot(rootDir) {
-  const folders = await findSkillPackages(rootDir);
+function looseSkillKey(skillsRoot, folder, tag, scope) {
+  const rel = (0, import_node_path20.relative)((0, import_node_path20.resolve)(skillsRoot), (0, import_node_path20.resolve)(folder)).split(import_node_path20.sep).join("/") || (0, import_node_path20.basename)(folder);
+  return `skill:${tag}/${rel}@${scope}`;
+}
+async function discoverLooseSkills(skillsDir, tag, scope) {
+  const resolvedRoot = (0, import_node_path20.resolve)(skillsDir);
+  const packages = (await findSkillPackagesWithMtime(skillsDir)).filter((p) => (0, import_node_path20.resolve)(p.folder) !== resolvedRoot);
+  return packages.map(({ folder, newestMtimeMs }) => ({
+    key: looseSkillKey(resolvedRoot, folder, tag, scope),
+    installPath: folder,
+    version: scope,
+    lastUpdated: new Date(newestMtimeMs).toISOString()
+  }));
+}
+async function dedupeSkillsByResolvedPath(skills) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const skill of skills) {
+    let canonical = skill.installPath;
+    try {
+      canonical = await (0, import_promises9.realpath)(skill.installPath);
+    } catch {
+    }
+    if (seen.has(canonical))
+      continue;
+    seen.add(canonical);
+    out.push(skill);
+  }
+  return out;
+}
+async function discoverLooseSkillsAcrossRoots(roots) {
+  const lists = await Promise.all(roots.map(async ({ dir, tag, scope }) => {
+    try {
+      return await discoverLooseSkills(dir, tag, scope);
+    } catch {
+      return [];
+    }
+  }));
+  return lists.length <= 1 ? lists[0] ?? [] : dedupeSkillsByResolvedPath(lists.flat());
+}
+async function computeSkillIdsForRoot(rootDir, logger) {
+  const folders = (await findSkillPackagesWithMtime(rootDir)).map((p) => p.folder);
   const out = [];
   for (const folder of folders) {
     try {
-      const entries = await entriesFromDirectory(folder);
+      const entries = await entriesFromDirectory(folder, MAX_SKILL_BYTES);
+      if (entries.length === 0) {
+        logger?.warn("Skill enumerates to no entries; not analyzable, skipping", { folder });
+        continue;
+      }
       const { skillId } = computeSkillId(entries);
       out.push({ folder, skillId });
-    } catch {
+    } catch (e) {
+      if (e instanceof SkillTooLargeError) {
+        logger?.warn("Skill directory exceeds 50 MB limit; skipping", { folder });
+      }
     }
   }
   return out;
 }
 
+// ../core/dist/skill-pending.js
+var import_promises10 = require("node:fs/promises");
+var import_node_path21 = require("node:path");
+init_config();
+init_file_utils();
+init_types2();
+var SCHEMA_VERSION2 = 1;
+var PENDING_TTL_MS = 60 * 60 * 1e3;
+function defaultPendingPath() {
+  return (0, import_node_path21.join)(resolvePath(SAGE_DIR), "skill_pending.json");
+}
+async function loadPendingMarker(pendingPath = defaultPendingPath(), logger = nullLogger) {
+  let raw;
+  try {
+    raw = await getFileContent(pendingPath);
+  } catch {
+    return { entries: {} };
+  }
+  try {
+    const data = JSON.parse(raw);
+    const rawEntries = data.entries ?? {};
+    const now = Date.now();
+    const entries = {};
+    for (const [skillId, entry] of Object.entries(rawEntries)) {
+      const folder = entry.folder;
+      const submittedAt = entry.submitted_at;
+      if (!folder || !submittedAt)
+        continue;
+      const ts = Date.parse(submittedAt);
+      if (!isFreshTimestamp(ts, PENDING_TTL_MS, now))
+        continue;
+      entries[skillId] = {
+        folder,
+        submittedAt,
+        agentRuntime: typeof entry.agent_runtime === "string" ? entry.agent_runtime : void 0,
+        containerKey: typeof entry.container_key === "string" ? entry.container_key : void 0
+      };
+    }
+    return { entries };
+  } catch (e) {
+    logger.warn(`Failed to load pending marker from ${pendingPath}`, { error: String(e) });
+    return { entries: {} };
+  }
+}
+async function savePendingMarker(marker, pendingPath = defaultPendingPath(), logger = nullLogger) {
+  if (Object.keys(marker.entries).length === 0) {
+    try {
+      await (0, import_promises10.unlink)(pendingPath);
+    } catch (e) {
+      if (!e || typeof e !== "object" || e.code !== "ENOENT") {
+        logger.warn(`Failed to delete empty pending marker at ${pendingPath}`, {
+          error: String(e)
+        });
+      }
+    }
+    return;
+  }
+  try {
+    const data = {
+      schema_version: SCHEMA_VERSION2,
+      entries: Object.fromEntries(Object.entries(marker.entries).map(([skillId, entry]) => [
+        skillId,
+        {
+          folder: entry.folder,
+          submitted_at: entry.submittedAt,
+          agent_runtime: entry.agentRuntime,
+          container_key: entry.containerKey
+        }
+      ]))
+    };
+    await atomicWriteJson(pendingPath, data);
+  } catch (e) {
+    logger.warn(`Failed to save pending marker to ${pendingPath}`, { error: String(e) });
+  }
+}
+function isPending(marker, skillId) {
+  return skillId in marker.entries;
+}
+function addPending(marker, skillId, folder, origin = {}) {
+  marker.entries[skillId] = {
+    folder,
+    submittedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    agentRuntime: origin.agentRuntime,
+    containerKey: origin.containerKey
+  };
+}
+function removePending(marker, skillId) {
+  delete marker.entries[skillId];
+}
+function listPending(marker) {
+  return Object.entries(marker.entries).map(([skillId, entry]) => ({
+    skillId,
+    folder: entry.folder,
+    agentRuntime: entry.agentRuntime,
+    containerKey: entry.containerKey
+  }));
+}
+
+// ../core/dist/skill-verdict-cache.js
+var import_node_path22 = require("node:path");
+init_config();
+init_file_utils();
+init_types2();
+var SCHEMA_VERSION3 = 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 mergeSources(existing, incoming) {
+  const merged = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const source of [...existing ?? [], ...incoming ?? []]) {
+    const key = source.agentRuntime ?? "";
+    if (seen.has(key))
+      continue;
+    seen.add(key);
+    merged.push(source);
+  }
+  return merged.length > 0 ? merged : void 0;
+}
+function defaultCachePath2() {
+  return (0, import_node_path22.join)(resolvePath(SAGE_DIR), "skill_verdict_cache.json");
+}
+async function loadSkillVerdictCache(cachePath = defaultCachePath2(), ttlMs = DEFAULT_VERDICT_TTL_MS, logger = nullLogger) {
+  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] = {
+        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 (pruned > 0) {
+      logger.debug(`Pruned ${pruned} stale verdict(s) from cache`, { cachePath });
+      await saveSkillVerdictCache(cache2, cachePath, logger);
+    }
+    return cache2;
+  } catch (e) {
+    logger.warn(`Failed to load verdict cache from ${cachePath}`, { error: String(e) });
+    return { entries: {} };
+  }
+}
+async function saveSkillVerdictCache(cache2, cachePath = defaultCachePath2(), logger = nullLogger) {
+  try {
+    const data = {
+      schema_version: SCHEMA_VERSION3,
+      entries: Object.fromEntries(Object.entries(cache2.entries).map(([skillId, v]) => [
+        skillId,
+        {
+          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);
+  } catch (e) {
+    logger.warn(`Failed to save verdict cache to ${cachePath}`, { error: String(e) });
+  }
+}
+function getVerdict(cache2, skillId, ttlMs = DEFAULT_VERDICT_TTL_MS) {
+  const entry = cache2.entries[skillId];
+  if (!entry)
+    return null;
+  const ts = Date.parse(entry.analyzedAt);
+  if (!isFreshTimestamp(ts, ttlMs))
+    return null;
+  return entry;
+}
+function putVerdict(cache2, skillId, verdict) {
+  const existing = cache2.entries[skillId];
+  cache2.entries[skillId] = {
+    ...verdict,
+    sources: mergeSources(existing?.sources, verdict.sources),
+    analyzedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
 // ../core/dist/plugin-scanner.js
 init_types2();
 var SCANNABLE_EXTENSIONS2 = /* @__PURE__ */ new Set([
@@ -19274,15 +20123,34 @@ var SCANNABLE_EXTENSIONS2 = /* @__PURE__ */ new Set([
 var MAX_FILE_SIZE = 512 * 1024;
 async function walkPluginFiles(installPath, logger) {
   const files = [];
+  const visited = /* @__PURE__ */ new Set();
+  let rootReal;
+  try {
+    rootReal = await (0, import_promises11.realpath)((0, import_node_path23.resolve)(installPath));
+  } catch (e) {
+    logger.warn(`Error walking plugin path ${installPath}`, { error: String(e) });
+    return files;
+  }
   async function walk(dirOrFile) {
+    let real;
+    try {
+      real = await (0, import_promises11.realpath)(dirOrFile);
+    } catch {
+      return;
+    }
+    if (visited.has(real))
+      return;
+    if (!isContained(real, rootReal))
+      return;
+    visited.add(real);
     let stats;
     try {
-      stats = await (0, import_promises9.stat)(dirOrFile);
+      stats = await (0, import_promises11.stat)(dirOrFile);
     } catch {
       return;
     }
     if (stats.isFile()) {
-      if (SCANNABLE_EXTENSIONS2.has((0, import_node_path18.extname)(dirOrFile).toLowerCase()) && stats.size <= MAX_FILE_SIZE) {
+      if (SCANNABLE_EXTENSIONS2.has((0, import_node_path23.extname)(dirOrFile).toLowerCase()) && stats.size <= MAX_FILE_SIZE) {
         files.push(dirOrFile);
       }
       return;
@@ -19290,32 +20158,41 @@ async function walkPluginFiles(installPath, logger) {
     if (stats.isDirectory()) {
       let entries;
       try {
-        entries = await (0, import_promises9.readdir)(dirOrFile);
+        entries = await (0, import_promises11.readdir)(dirOrFile);
       } catch {
         return;
       }
       for (const entry of entries) {
         if (SKIP_DIRS.has(entry))
           continue;
-        const fullPath = (0, import_node_path18.join)(dirOrFile, entry);
+        const fullPath = (0, import_node_path23.join)(dirOrFile, entry);
         await walk(fullPath);
       }
     }
   }
   try {
-    await walk(installPath);
+    await walk((0, import_node_path23.resolve)(installPath));
   } catch (e) {
     logger.warn(`Error walking plugin path ${installPath}`, { error: String(e) });
   }
   return files;
 }
 async function scanPlugin(plugin, options = {}) {
-  const { checkUrls = true, checkFileHashes = true, checkSkills = true, amsiClient = null, logger = nullLogger } = options;
+  const { checkUrls = true, checkFileHashes = true, checkSkills = true, amsiClient = null, logger = nullLogger, skillVerdictCachePath, skillPendingPath, loggingConfig, skillVerdictTtlMs, uploadEnabled = true, deferUnknownSkills = false, agentRuntime } = options;
   const result = { plugin, findings: [] };
-  const skillCheckPromise = checkSkills ? runSkillCheck(plugin, result.findings, logger) : Promise.resolve();
+  const skillCheckPromise = checkSkills ? runSkillCheck(plugin, result.findings, logger, {
+    verdictCachePath: skillVerdictCachePath,
+    pendingPath: skillPendingPath,
+    loggingConfig,
+    verdictTtlMs: skillVerdictTtlMs,
+    uploadEnabled,
+    deferUnknownSkills,
+    agentRuntime
+  }) : Promise.resolve(false);
   const files = await walkPluginFiles(plugin.installPath, logger);
   if (files.length === 0) {
-    await skillCheckPromise;
+    if (await skillCheckPromise)
+      result.deferCache = true;
     return result;
   }
   const allUrls = [];
@@ -19331,7 +20208,7 @@ async function scanPlugin(plugin, options = {}) {
     }
     if (amsiClient) {
       try {
-        const scanName = `${plugin.key}/${(0, import_node_path18.relative)(plugin.installPath, filePath)}`;
+        const scanName = `${plugin.key}/${(0, import_node_path23.relative)(plugin.installPath, filePath)}`;
         const amsiResult = await amsiClient.scanString("Plugin", scanName, content);
         if (amsiResult && (amsiResult.isDetected || amsiResult.isBlockedByAdmin)) {
           result.findings.push({
@@ -19339,7 +20216,7 @@ async function scanPlugin(plugin, options = {}) {
             title: `AMSI detection (result=${amsiResult.amsiResult})`,
             severity: "critical",
             artifact: content.slice(0, 200),
-            sourceFile: (0, import_node_path18.relative)(plugin.installPath, filePath)
+            sourceFile: (0, import_node_path23.relative)(plugin.installPath, filePath)
           });
         }
       } catch {
@@ -19392,7 +20269,7 @@ async function scanPlugin(plugin, options = {}) {
               title: `Malicious file (${fr.detectionNames.join(", ") || "unknown"})`,
               severity: "critical",
               artifact: fr.sha256,
-              sourceFile: (0, import_node_path18.relative)(plugin.installPath, filePath)
+              sourceFile: (0, import_node_path23.relative)(plugin.installPath, filePath)
             });
           }
         }
@@ -19400,46 +20277,109 @@ async function scanPlugin(plugin, options = {}) {
     } catch {
     }
   })() : Promise.resolve();
-  await Promise.all([urlCheckPromise, fileCheckPromise, skillCheckPromise]);
+  const [, , skillDeferCache] = await Promise.all([
+    urlCheckPromise,
+    fileCheckPromise,
+    skillCheckPromise
+  ]);
+  if (skillDeferCache)
+    result.deferCache = true;
   return result;
 }
-async function runSkillCheck(plugin, findings, logger) {
+function pushSkillFindingIfRisky(findings, plugin, skillId, folder, verdict) {
+  const risk = (verdict.verdict ?? "").toUpperCase();
+  if (risk !== "HIGH" && risk !== "CRITICAL")
+    return;
+  const severity = risk === "CRITICAL" ? "critical" : "warning";
+  findings.push({
+    threatId: "SKILL_CHECK",
+    title: verdict.summary?.trim() || (risk === "CRITICAL" ? "Malicious skill detected" : "Suspicious skill detected"),
+    severity,
+    artifact: skillId.slice(0, 16),
+    sourceFile: (0, import_node_path23.relative)(plugin.installPath, folder) || "."
+  });
+}
+async function runSkillCheck(plugin, findings, logger, paths = {}) {
   try {
-    const skills = await computeSkillIdsForRoot(plugin.installPath);
+    const skills = await computeSkillIdsForRoot(plugin.installPath, logger);
     if (skills.length === 0)
-      return;
-    const ids = skills.map((s) => s.skillId);
+      return false;
+    const verdictCache = await loadSkillVerdictCache(paths.verdictCachePath, paths.verdictTtlMs, logger);
+    const uncached = [];
+    for (const skill of skills) {
+      const cached = getVerdict(verdictCache, skill.skillId, paths.verdictTtlMs);
+      if (cached) {
+        pushSkillFindingIfRisky(findings, plugin, skill.skillId, skill.folder, cached);
+      } else {
+        uncached.push(skill);
+      }
+    }
+    if (uncached.length === 0)
+      return false;
     const client = new SkillCheckClient(void 0, logger);
-    const verdicts = await client.checkSkills(ids);
-    for (const { folder, skillId } of skills) {
-      const verdict = verdicts.get(skillId);
-      if (!verdict)
+    const verdicts = await client.checkSkills(uncached.map((s) => s.skillId));
+    const marker = await loadPendingMarker(paths.pendingPath, logger);
+    let cacheModified = false;
+    let markerModified = false;
+    let lookupFailed = false;
+    let graceDeferred = false;
+    for (const { folder, skillId } of uncached) {
+      if (!verdicts.has(skillId)) {
+        lookupFailed = true;
         continue;
-      const risk = (verdict.overallRiskLevel ?? "").toUpperCase();
-      if (risk !== "HIGH" && risk !== "CRITICAL")
-        continue;
-      const severity = risk === "CRITICAL" ? "critical" : "warning";
-      findings.push({
-        threatId: "SKILL_CHECK",
-        title: verdict.summary?.trim() || `Risky skill detected (${risk})`,
-        severity,
-        artifact: skillId.slice(0, 16),
-        sourceFile: (0, import_node_path18.relative)(plugin.installPath, folder) || ".",
-        recommendations: verdict.recommendations.length > 0 ? verdict.recommendations : void 0
-      });
+      }
+      const verdict = verdicts.get(skillId) ?? null;
+      if (verdict) {
+        putVerdict(verdictCache, skillId, {
+          verdict: verdict.verdict,
+          summary: verdict.summary,
+          skillName: (0, import_node_path23.basename)(folder),
+          sources: [{ agentRuntime: paths.agentRuntime, containerKey: plugin.key }]
+        });
+        cacheModified = true;
+        pushSkillFindingIfRisky(findings, plugin, skillId, folder, verdict);
+        if (isPending(marker, skillId)) {
+          removePending(marker, skillId);
+          markerModified = true;
+        }
+      } else if (!isPending(marker, skillId)) {
+        if (paths.uploadEnabled === false) {
+          if (paths.deferUnknownSkills)
+            graceDeferred = true;
+        } else {
+          addPending(marker, skillId, folder, {
+            agentRuntime: paths.agentRuntime,
+            containerKey: plugin.key
+          });
+          markerModified = true;
+          if (paths.loggingConfig) {
+            logSkillQueued(paths.loggingConfig, skillId, plugin.key, folder).catch(() => {
+            });
+          }
+        }
+      }
     }
+    if (cacheModified)
+      await saveSkillVerdictCache(verdictCache, paths.verdictCachePath, logger);
+    if (markerModified)
+      await savePendingMarker(marker, paths.pendingPath, logger);
+    const anyStillPending = uncached.some(({ skillId }) => isPending(marker, skillId));
+    return markerModified || anyStillPending || lookupFailed || graceDeferred;
   } catch (e) {
     logger.debug("Skill check failed", { error: String(e) });
+    return false;
   }
 }
 
 // ../core/dist/session-start.js
 var import_node_child_process2 = require("node:child_process");
 var import_node_fs4 = require("node:fs");
+var import_node_path25 = require("node:path");
 init_config();
 init_file_utils();
 
 // ../core/dist/session-start-scan.js
+var import_node_path24 = require("node:path");
 init_config();
 init_types2();
 function fromCachedFinding(finding) {
@@ -19522,6 +20462,9 @@ async function scanAllPlugins(context, config2, plugins, exceptions, amsiClient,
     deniedByException: 0,
     findingsCount: 0
   };
+  const skillPendingPath = context.sageDirPath ? (0, import_node_path24.join)(context.sageDirPath, "skill_pending.json") : void 0;
+  const skillVerdictCachePath = context.sageDirPath ? (0, import_node_path24.join)(context.sageDirPath, "skill_verdict_cache.json") : void 0;
+  const cacheTtlMs = skillCacheTtlMs(config2);
   for (const plugin of plugins) {
     const denyMatch = findPluginDenyException(exceptions, plugin.key);
     if (denyMatch) {
@@ -19546,7 +20489,7 @@ async function scanAllPlugins(context, config2, plugins, exceptions, amsiClient,
       stats.allowedByException += 1;
       continue;
     }
-    const cached = getCached(cache2, plugin.key, plugin.version, plugin.lastUpdated);
+    const cached = getCached(cache2, plugin.key, plugin.version, plugin.lastUpdated, cacheTtlMs);
     if (cached && cached.findings.length === 0) {
       stats.cacheHitsClean += 1;
       continue;
@@ -19565,11 +20508,23 @@ async function scanAllPlugins(context, config2, plugins, exceptions, amsiClient,
     const result = await scanPlugin(plugin, {
       checkUrls: context.checkUrls ?? true,
       checkFileHashes: context.checkFileHashes ?? true,
+      checkSkills: config2.skill_check.enabled,
+      uploadEnabled: context.uploadUnknownSkills ?? config2.skill_check.upload_enabled,
+      deferUnknownSkills: context.deferUnknownSkills,
       amsiClient,
-      logger
+      logger,
+      skillPendingPath,
+      skillVerdictCachePath,
+      skillVerdictTtlMs: cacheTtlMs,
+      loggingConfig: config2.logging,
+      agentRuntime: context.agentRuntime
     });
-    storeResult(cache2, plugin.key, plugin.version, plugin.lastUpdated, result.findings.map(toFindingData));
-    cacheModified = true;
+    if (result.deferCache) {
+      logger.debug("Plugin cache deferred (skill verdict pending)", { plugin: plugin.key });
+    } else {
+      storeResult(cache2, plugin.key, plugin.version, plugin.lastUpdated, result.findings.map(toFindingData));
+      cacheModified = true;
+    }
     if (result.findings.length > 0) {
       stats.findingsCount += result.findings.length;
       resultsWithFindings.push(result);
@@ -19596,6 +20551,7 @@ async function scanAllPlugins(context, config2, plugins, exceptions, amsiClient,
 init_types2();
 
 // ../core/dist/version-check.js
+init_config();
 init_types2();
 var DEFAULT_TIMEOUT_MS3 = 5e3;
 function isNewerVersion(current, latest) {
@@ -19622,11 +20578,20 @@ async function checkForUpdate(currentVersion, logger = nullLogger, timeoutMs = D
       logger.debug("Skipping version check: missing installation id");
       return null;
     }
+    let config2 = context.config;
+    if (!config2) {
+      try {
+        config2 = await loadConfig(context.configPath, logger);
+      } catch (err) {
+        logger.debug(`Version check config load failed: ${err}`);
+      }
+    }
     const envelope = buildSageProxyEnvelope({
       iid: context.iid,
       versionApp: currentVersion,
       agentRuntime: context.agentRuntime,
-      agentRuntimeVersion: context.agentRuntimeVersion ?? "unknown"
+      agentRuntimeVersion: context.agentRuntimeVersion ?? "unknown",
+      config: config2
     });
     const extendedInfo = await loadExtendedInfo(void 0, logger).catch(() => null);
     const enriched = mergeExtendedInfo(envelope, extendedInfo);
@@ -19666,6 +20631,8 @@ async function runSessionStart(ctx) {
   const sageDirPath = resolvePath(ctx.sageDirPath ?? "~/.sage");
   pruneOrphanedTmpFiles(sageDirPath).catch(() => {
   });
+  deployConfigDefaults(sageDirPath, logger).catch(() => {
+  });
   maybeSpawnModelDownloadWorker({
     sageDirPath,
     workerPath: ctx.modelDownloadWorkerPath,
@@ -19676,6 +20643,13 @@ async function runSessionStart(ctx) {
     logger
   }).catch(() => {
   });
+  const rollout = await resolveSkillUploadRollout({
+    sageDirPath,
+    configPath: ctx.configPath,
+    version: ctx.version,
+    logger,
+    commitNotice: ctx.commitUploadNotice ?? true
+  });
   const iidPromise = getInstallationId(sageDirPath).catch(() => void 0);
   const [scanResults, versionCheck] = await Promise.all([
     runSessionStartScan({
@@ -19687,7 +20661,11 @@ async function runSessionStart(ctx) {
       configPath: ctx.configPath,
       scanCachePath: ctx.scanCachePath,
       checkUrls: ctx.checkUrls,
-      checkFileHashes: ctx.checkFileHashes
+      checkFileHashes: ctx.checkFileHashes,
+      sageDirPath,
+      agentRuntime: ctx.agentRuntime,
+      uploadUnknownSkills: rollout.uploadActive,
+      deferUnknownSkills: rollout.deferUnknownSkills
     }),
     iidPromise.then((iid) => {
       if (!iid) {
@@ -19696,11 +20674,25 @@ async function runSessionStart(ctx) {
       return checkForUpdate(ctx.version, logger, void 0, {
         agentRuntime: ctx.agentRuntime,
         agentRuntimeVersion: ctx.agentRuntimeVersion,
-        iid
+        iid,
+        configPath: ctx.configPath
       });
     }).catch(() => null)
   ]);
-  return { scanResults, versionCheck };
+  maybeSpawnSkillUploadWorker({
+    sageDirPath,
+    workerPath: ctx.skillUploadWorkerPath,
+    configPath: ctx.configPath,
+    agentRuntime: ctx.agentRuntime,
+    uploadActive: rollout.uploadActive,
+    logger
+  }).catch(() => {
+  });
+  return {
+    scanResults,
+    versionCheck,
+    notices: rollout.showNotice ? [SKILL_UPLOAD_NOTICE.id] : []
+  };
 }
 async function maybeSpawnModelDownloadWorker(args) {
   if (!args.workerPath) {
@@ -19746,6 +20738,7 @@ async function maybeSpawnModelDownloadWorker(args) {
   const spawned = spawnModelDownloadWorker({
     sageDirPath: args.sageDirPath,
     workerPath: args.workerPath,
+    configPath: args.configPath,
     agentRuntime: args.agentRuntime,
     agentRuntimeVersion: args.agentRuntimeVersion,
     versionApp: args.versionApp,
@@ -19757,6 +20750,9 @@ async function maybeSpawnModelDownloadWorker(args) {
     missingModels
   });
 }
+function bunRuntimeEnv() {
+  return process.versions.bun ? { BUN_BE_BUN: "1" } : {};
+}
 function spawnModelDownloadWorker(args) {
   const logger = args.logger ?? nullLogger;
   try {
@@ -19765,7 +20761,9 @@ function spawnModelDownloadWorker(args) {
       stdio: "ignore",
       env: {
         ...process.env,
+        ...bunRuntimeEnv(),
         SAGE_DIR: args.sageDirPath,
+        SAGE_CONFIG_PATH: args.configPath ?? "",
         SAGE_AGENT_RUNTIME: String(args.agentRuntime ?? "unknown"),
         SAGE_AGENT_RUNTIME_VERSION: args.agentRuntimeVersion ?? "",
         SAGE_VERSION_APP: args.versionApp ?? "",
@@ -19779,9 +20777,83 @@ function spawnModelDownloadWorker(args) {
     return false;
   }
 }
+async function maybeSpawnSkillUploadWorker(args) {
+  if (!args.uploadActive) {
+    args.logger.debug("Skill upload worker skipped", {
+      result: "skipped",
+      skippedReason: "upload_inactive"
+    });
+    return;
+  }
+  try {
+    const config2 = await loadConfig(args.configPath, args.logger);
+    if (!config2.skill_check.enabled) {
+      args.logger.debug("Skill upload worker skipped", {
+        result: "skipped",
+        skippedReason: "skill_check_disabled"
+      });
+      return;
+    }
+  } catch {
+  }
+  if (!args.workerPath) {
+    args.logger.debug("Skill upload worker skipped", {
+      result: "skipped",
+      skippedReason: "missing_worker_path"
+    });
+    return;
+  }
+  if (!(0, import_node_fs4.existsSync)(args.workerPath)) {
+    args.logger.debug("Skill upload worker skipped", {
+      result: "skipped",
+      skippedReason: "worker_script_not_found",
+      workerPath: args.workerPath
+    });
+    return;
+  }
+  const marker = await loadPendingMarker((0, import_node_path25.join)(args.sageDirPath, "skill_pending.json"), args.logger);
+  const pendingCount = listPending(marker).length;
+  if (pendingCount === 0) {
+    args.logger.debug("Skill upload worker skipped", {
+      result: "skipped",
+      skippedReason: "no_pending_skills"
+    });
+    return;
+  }
+  const spawned = spawnSkillUploadWorker({
+    sageDirPath: args.sageDirPath,
+    workerPath: args.workerPath,
+    agentRuntime: args.agentRuntime,
+    logger: args.logger
+  });
+  args.logger.debug("Skill upload worker spawn completed", {
+    result: spawned ? "spawned" : "failed",
+    pendingCount
+  });
+}
+function spawnSkillUploadWorker(args) {
+  const logger = args.logger ?? nullLogger;
+  try {
+    const child = (0, import_node_child_process2.spawn)(process.execPath, [args.workerPath], {
+      detached: true,
+      stdio: "ignore",
+      env: {
+        ...process.env,
+        ...bunRuntimeEnv(),
+        SAGE_DIR: args.sageDirPath,
+        SAGE_AGENT_RUNTIME: String(args.agentRuntime ?? "unknown")
+      }
+    });
+    child.unref();
+    return true;
+  } catch (err) {
+    logger.warn("Failed to spawn skill upload worker", { error: String(err) });
+    return false;
+  }
+}
 
 // ../core/dist/scan-handler.js
-async function runPluginScan(logger, context, plugins, threatsDir, trustedDomainsDir, version, agentRuntime, branding2 = defaultBranding, modelDownloadWorkerPath, style = "verbose", agentRuntimeVersion) {
+async function runPluginScan(logger, context, plugins, threatsDir, trustedDomainsDir, version, agentRuntime, branding2 = defaultBranding, modelDownloadWorkerPath, style = "verbose", agentRuntimeVersion, skillUploadWorkerPath, onNotices, commitUploadNotice, announceCleanScans = true) {
   logger.debug(`${branding2.name} plugin scan started (${context})`, {
     agentRuntime,
     pluginsCount: plugins.length,
@@ -19796,8 +20868,20 @@ async function runPluginScan(logger, context, plugins, threatsDir, trustedDomain
     logger,
     agentRuntime,
     agentRuntimeVersion,
-    modelDownloadWorkerPath
+    modelDownloadWorkerPath,
+    skillUploadWorkerPath,
+    commitUploadNotice
   });
+  if (result.notices && result.notices.length > 0) {
+    logger.debug(`${branding2.name} session-start produced notices`, {
+      context,
+      noticeIds: result.notices,
+      forwarded: Boolean(onNotices)
+    });
+    onNotices?.(result.notices);
+  } else {
+    logger.debug(`${branding2.name} session-start produced no notices`, { context });
+  }
   const findingsCount = result.scanResults.reduce((total, scanResult) => total + scanResult.findings.length, 0);
   const completionData = {
     agentRuntime,
@@ -19811,10 +20895,13 @@ async function runPluginScan(logger, context, plugins, threatsDir, trustedDomain
   } else {
     logger.debug(`${branding2.name} plugin scan (${context}) complete`, completionData);
   }
+  if (findingsCount === 0 && !announceCleanScans) {
+    return "";
+  }
   return formatSessionStartMessage(version, result, branding2, style);
 }
 function createScanHandler(options) {
-  const { logger, context, discoverPlugins: discoverPlugins2, selfPrefix, threatsDir, trustedDomainsDir, version, agentRuntime, agentRuntimeVersion, branding: branding2 = defaultBranding, onResult, modelDownloadWorkerPath, style = "verbose" } = options;
+  const { logger, context, discoverPlugins: discoverPlugins2, selfPrefix, threatsDir, trustedDomainsDir, version, agentRuntime, agentRuntimeVersion, branding: branding2 = defaultBranding, onResult, onNotices, modelDownloadWorkerPath, skillUploadWorkerPath, style = "verbose", commitUploadNotice, announceCleanScans = true } = options;
   return async () => {
     try {
       let plugins = await discoverPlugins2();
@@ -19822,8 +20909,10 @@ function createScanHandler(options) {
       if (plugins.length === 0) {
         logger.debug(`${branding2.name} plugin scan (${context}): no plugins to scan after filtering`);
       }
-      const msg = await runPluginScan(logger, context, plugins, threatsDir, trustedDomainsDir, version, agentRuntime, branding2, modelDownloadWorkerPath, style, agentRuntimeVersion);
-      onResult?.(msg);
+      const msg = await runPluginScan(logger, context, plugins, threatsDir, trustedDomainsDir, version, agentRuntime, branding2, modelDownloadWorkerPath, style, agentRuntimeVersion, skillUploadWorkerPath, onNotices, commitUploadNotice, announceCleanScans);
+      if (msg !== "") {
+        onResult?.(msg);
+      }
     } catch (e) {
       logger.error(`${branding2.name} ${context} scan failed`, { error: String(e) });
     }
@@ -19861,19 +20950,19 @@ function canonicalizeToolName(map, rawName) {
 init_types2();
 
 // src/bundled-dirs.ts
-var import_node_path19 = require("node:path");
-var packageRoot = (0, import_node_path19.resolve)(__dirname, "..");
+var import_node_path26 = require("node:path");
+var packageRoot = (0, import_node_path26.resolve)(__dirname, "..");
 function getBundledDataDirs() {
   return {
-    threatsDir: (0, import_node_path19.join)(packageRoot, "resources", "threats"),
-    trustedDomainsDir: (0, import_node_path19.join)(packageRoot, "resources", "trusted-domains")
+    threatsDir: (0, import_node_path26.join)(packageRoot, "resources", "threats"),
+    trustedDomainsDir: (0, import_node_path26.join)(packageRoot, "resources", "trusted-domains")
   };
 }
 var cachedVersion;
 function getSageVersion() {
   if (cachedVersion) return cachedVersion;
   try {
-    const pkg = JSON.parse(getFileContentSync((0, import_node_path19.join)(packageRoot, "package.json"), "utf-8"));
+    const pkg = JSON.parse(getFileContentSync((0, import_node_path26.join)(packageRoot, "package.json"), "utf-8"));
     cachedVersion = pkg.version ?? "0.0.0";
   } catch {
     cachedVersion = "0.0.0";
@@ -19882,37 +20971,41 @@ function getSageVersion() {
 }
 
 // src/startup-scan.ts
-var import_node_path21 = require("node:path");
+var import_node_path28 = require("node:path");
 
 // src/plugin-discovery.ts
-var import_promises10 = require("node:fs/promises");
+var import_promises12 = require("node:fs/promises");
 var import_node_os4 = require("node:os");
-var import_node_path20 = require("node:path");
-var DEFAULT_EXTENSIONS_DIR = (0, import_node_path20.join)((0, import_node_os4.homedir)(), ".openclaw", "extensions");
-async function discoverOpenClawPlugins(logger, extensionsDir = DEFAULT_EXTENSIONS_DIR, branding2 = defaultBranding) {
+var import_node_path27 = require("node:path");
+var DEFAULT_EXTENSIONS_DIR = (0, import_node_path27.join)((0, import_node_os4.homedir)(), ".openclaw", "extensions");
+var SKILL_ROOTS = [
+  { dir: (0, import_node_path27.join)(getHomeDir(), ".agents", "skills"), tag: "agents", scope: "personal" },
+  { dir: (0, import_node_path27.join)(getHomeDir(), ".openclaw", "skills"), tag: "openclaw", scope: "personal" }
+];
+async function discoverOpenClawPlugins(logger, extensionsDir = DEFAULT_EXTENSIONS_DIR, branding2 = defaultBranding, skillRoots = SKILL_ROOTS) {
   logger.debug(`${branding2.name} plugin discovery: scanning extensions directory`, {
     path: extensionsDir
   });
+  const plugins = [];
   let entries;
   try {
-    entries = await (0, import_promises10.readdir)(extensionsDir);
+    entries = await (0, import_promises12.readdir)(extensionsDir);
   } catch {
     logger.debug("OpenClaw extensions directory not found", { path: extensionsDir });
-    return [];
+    entries = [];
   }
-  const plugins = [];
   for (const entry of entries) {
-    const extDir = (0, import_node_path20.join)(extensionsDir, entry);
+    const extDir = (0, import_node_path27.join)(extensionsDir, entry);
     let stats;
     try {
-      stats = await (0, import_promises10.stat)(extDir);
+      stats = await (0, import_promises12.stat)(extDir);
       if (!stats.isDirectory()) continue;
     } catch {
       continue;
     }
     let pkg;
     try {
-      const pkgPath = (0, import_node_path20.join)(extDir, "package.json");
+      const pkgPath = (0, import_node_path27.join)(extDir, "package.json");
       const raw = await getFileContent(pkgPath);
       pkg = JSON.parse(raw);
     } catch {
@@ -19934,11 +21027,14 @@ async function discoverOpenClawPlugins(logger, extensionsDir = DEFAULT_EXTENSION
     });
   }
   logger.debug(`${branding2.name} plugin discovery: found ${plugins.length} extension(s)`);
+  const skills = await discoverLooseSkillsAcrossRoots(skillRoots);
+  logger.debug(`${branding2.name} skill discovery: found ${skills.length} loose skill(s)`);
+  plugins.push(...skills);
   return plugins;
 }
 
 // src/startup-scan.ts
-function createOpenClawScanHandler(logger, context, branding2 = defaultBranding, onResult) {
+function createOpenClawScanHandler(logger, context, branding2 = defaultBranding, onResult, announceCleanScans = true) {
   const { threatsDir, trustedDomainsDir } = getBundledDataDirs();
   const version = getSageVersion();
   return createScanHandler({
@@ -19953,29 +21049,58 @@ function createOpenClawScanHandler(logger, context, branding2 = defaultBranding,
     // No agentRuntimeVersion: the OpenClaw plugin API exposes no host version.
     branding: branding2,
     onResult,
-    modelDownloadWorkerPath: (0, import_node_path21.resolve)(__dirname, "model-download-worker.cjs")
+    // No onNotices: OpenClaw delivers the one-time notice from
+    // `before_agent_start` (a different process/turn than this scan) via
+    // takePendingNotices, so the scan-time callback would never fire.
+    modelDownloadWorkerPath: (0, import_node_path28.resolve)(__dirname, "model-download-worker.cjs"),
+    skillUploadWorkerPath: (0, import_node_path28.resolve)(__dirname, "skill-upload-worker.cjs"),
+    // Don't commit the "shown" flag here — commit happens at delivery.
+    commitUploadNotice: false,
+    announceCleanScans
   });
 }
-function createStartupScanHandler(logger, branding2 = defaultBranding, onResult) {
-  return createOpenClawScanHandler(logger, "startup", branding2, onResult);
-}
-function createSessionScanHandler(logger, branding2 = defaultBranding, onResult) {
-  return createOpenClawScanHandler(logger, "session", branding2, onResult);
-}
-function createBeforeAgentStartHandler(getFindings, clearFindings, logger, branding2 = defaultBranding) {
-  return () => {
-    const findings = getFindings();
-    if (!findings) return void 0;
-    clearFindings();
-    logger.debug(`${branding2.name}: surfacing plugin scan findings via before_agent_start`);
-    const prependContext = [
-      '<security-alert source="sage-plugin-scan">',
-      findings,
-      "",
-      "Inform the user about these security findings.",
-      "</security-alert>"
-    ].join("\n");
-    return { prependContext };
+function createStartupScanHandler(logger, branding2 = defaultBranding, onResult, announceCleanScans = true) {
+  return createOpenClawScanHandler(logger, "startup", branding2, onResult, announceCleanScans);
+}
+function createSessionScanHandler(logger, branding2 = defaultBranding, onResult, announceCleanScans = true) {
+  return createOpenClawScanHandler(logger, "session", branding2, onResult, announceCleanScans);
+}
+function createBeforeAgentStartHandler(getSecurityFindings, clearFindings, logger, branding2 = defaultBranding) {
+  return (notices) => {
+    const findings = getSecurityFindings();
+    if (!notices && !findings) {
+      logger.debug(`${branding2.name}: before_agent_start - nothing pending to surface`);
+      return void 0;
+    }
+    if (findings) clearFindings();
+    logger.debug(`${branding2.name}: surfacing context via before_agent_start`, {
+      hasNotices: Boolean(notices),
+      hasFindings: Boolean(findings)
+    });
+    const blocks = [];
+    if (notices) {
+      blocks.push(
+        [
+          '<sage-notice source="sage-session-start">',
+          notices,
+          "",
+          "Relay this notice to the user. It is informational, not a security finding.",
+          "</sage-notice>"
+        ].join("\n")
+      );
+    }
+    if (findings) {
+      blocks.push(
+        [
+          '<security-alert source="sage-plugin-scan">',
+          findings,
+          "",
+          "Inform the user about these security findings.",
+          "</security-alert>"
+        ].join("\n")
+      );
+    }
+    return { prependContext: blocks.join("\n\n") };
   };
 }
 
@@ -20062,6 +21187,17 @@ function createToolCallHandler(approvalStore, logger, threatsDir, trustedDomains
     });
     try {
       const { toolName, params } = event;
+      if (captureEnabled()) {
+        await captureHookInput(
+          "PreToolUse",
+          { toolName, params, sessionKey: ctx?.sessionKey },
+          {
+            toolName: canonicalizeToolName(OPENCLAW_TOOL_MAP, toolName),
+            toolInput: normalizeToolInput(toolName, params)
+          },
+          { filePrefix: "openclaw-" }
+        );
+      }
       const artifacts = mapToolToArtifacts(toolName, params);
       if (!artifacts || artifacts.length === 0) {
         completeHook("skipped", { skippedReason: "no_artifacts" });
@@ -20102,6 +21238,7 @@ function createToolCallHandler(approvalStore, logger, threatsDir, trustedDomains
       }
       const maxReasons = 3;
       const reasons = verdict.reasons.length > 0 ? verdict.reasons.slice(0, maxReasons).join("; ") + (verdict.reasons.length > maxReasons ? `; ... and ${verdict.reasons.length - maxReasons} more` : "") : verdict.category;
+      const rule = ruleLabel(verdict);
       const intersected = artifacts.filter((a) => verdict.artifacts.includes(a.value));
       const flaggedArtifacts = intersected.length > 0 ? intersected : artifacts;
       completeHook("evaluated", {
@@ -20118,6 +21255,7 @@ function createToolCallHandler(approvalStore, logger, threatsDir, trustedDomains
           title: `${branding2.name}: ${verdict.category}`,
           description: [
             `Severity: ${verdict.severity}`,
+            ...rule ? [`Rule: ${rule}`] : [],
             `Reason: ${reasons}`,
             `Artifacts: ${summarizeArtifacts(artifacts)}`
           ].join("\n"),
@@ -20187,9 +21325,9 @@ ${notice}` : notice;
     const onFindings = (msg) => {
       pendingScanFindings = msg;
     };
-    const getPendingFindings = () => [pendingConfigurationWarnings, pendingScanFindings].filter(Boolean).join("\n\n") || null;
+    const getPendingSecurityFindings = () => [pendingConfigurationWarnings, pendingScanFindings].filter(Boolean).join("\n\n") || null;
     const beforeAgentStartHandler = createBeforeAgentStartHandler(
-      getPendingFindings,
+      getPendingSecurityFindings,
       () => {
         pendingConfigurationWarnings = null;
         pendingScanFindings = null;
@@ -20197,16 +21335,37 @@ ${notice}` : notice;
       logger,
       branding
     );
+    const resolveNoticeText = async () => {
+      try {
+        const ids = await takePendingNotices({ logger });
+        const text = ids.map((id) => formatNoticeById(id, branding)).filter(Boolean).join("\n\n");
+        logger.debug(`${branding.name}: notices resolved for delivery`, {
+          noticeIds: ids,
+          willShow: text.length > 0
+        });
+        return text.length > 0 ? text : null;
+      } catch (e) {
+        logger.warn(`${branding.name}: notice resolution failed`, { error: String(e) });
+        return null;
+      }
+    };
     api.on(
       "before_tool_call",
       createToolCallHandler(approvalStore, toolLogger, threatsDir, trustedDomainsDir, branding),
       { priority: 100 }
     );
-    api.on("gateway_start", createStartupScanHandler(scanLogger, branding, onFindings));
-    api.on("session_start", createSessionScanHandler(scanLogger, branding, onFindings));
+    api.on(
+      "gateway_start",
+      createStartupScanHandler(scanLogger, branding, onFindings, config.announce_clean_scans)
+    );
+    api.on(
+      "session_start",
+      createSessionScanHandler(scanLogger, branding, onFindings, config.announce_clean_scans)
+    );
     api.on("before_agent_start", async () => {
       await migrationCheckPromise;
-      return beforeAgentStartHandler();
+      const notices = await resolveNoticeText();
+      return beforeAgentStartHandler(notices);
     });
   }
 };