@gendigital/sage-openclaw 0.6.0 → 0.7.0

package/dist/index.cjs

@@ -3978,10 +3978,10 @@ var require_resolve_block_map = __commonJS({
       let offset = bm.offset;
       let commentEnd = null;
       for (const collItem of bm.items) {
-        const { start, key, sep: sep2, value } = collItem;
+        const { start, key, sep: sep3, value } = collItem;
         const keyProps = resolveProps.resolveProps(start, {
           indicator: "explicit-key-ind",
-          next: key ?? sep2?.[0],
+          next: key ?? sep3?.[0],
           offset,
           onError,
           parentIndent: bm.indent,
@@ -3995,7 +3995,7 @@ var require_resolve_block_map = __commonJS({
             else if ("indent" in key && key.indent !== bm.indent)
               onError(offset, "BAD_INDENT", startColMsg);
           }
-          if (!keyProps.anchor && !keyProps.tag && !sep2) {
+          if (!keyProps.anchor && !keyProps.tag && !sep3) {
             commentEnd = keyProps.end;
             if (keyProps.comment) {
               if (map.comment)
@@ -4019,7 +4019,7 @@ var require_resolve_block_map = __commonJS({
         ctx.atKey = false;
         if (utilMapIncludes.mapIncludes(ctx, map.items, keyNode))
           onError(keyStart, "DUPLICATE_KEY", "Map keys must be unique");
-        const valueProps = resolveProps.resolveProps(sep2 ?? [], {
+        const valueProps = resolveProps.resolveProps(sep3 ?? [], {
           indicator: "map-value-ind",
           next: value,
           offset: keyNode.range[2],
@@ -4035,7 +4035,7 @@ var require_resolve_block_map = __commonJS({
             if (ctx.options.strict && keyProps.start < valueProps.found.offset - 1024)
               onError(keyNode.range, "KEY_OVER_1024_CHARS", "The : indicator must be at most 1024 chars after the start of an implicit block mapping key");
           }
-          const valueNode = value ? composeNode(ctx, value, valueProps, onError) : composeEmptyNode(ctx, offset, sep2, null, valueProps, onError);
+          const valueNode = value ? composeNode(ctx, value, valueProps, onError) : composeEmptyNode(ctx, offset, sep3, null, valueProps, onError);
           if (ctx.schema.compat)
             utilFlowIndentCheck.flowIndentCheck(bm.indent, value, onError);
           offset = valueNode.range[2];
@@ -4126,7 +4126,7 @@ var require_resolve_end = __commonJS({
       let comment = "";
       if (end) {
         let hasSpace = false;
-        let sep2 = "";
+        let sep3 = "";
         for (const token of end) {
           const { source, type } = token;
           switch (type) {
@@ -4140,13 +4140,13 @@ var require_resolve_end = __commonJS({
               if (!comment)
                 comment = cb;
               else
-                comment += sep2 + cb;
-              sep2 = "";
+                comment += sep3 + cb;
+              sep3 = "";
               break;
             }
             case "newline":
               if (comment)
-                sep2 += source;
+                sep3 += source;
               hasSpace = true;
               break;
             default:
@@ -4189,18 +4189,18 @@ var require_resolve_flow_collection = __commonJS({
       let offset = fc.offset + fc.start.source.length;
       for (let i = 0; i < fc.items.length; ++i) {
         const collItem = fc.items[i];
-        const { start, key, sep: sep2, value } = collItem;
+        const { start, key, sep: sep3, value } = collItem;
         const props = resolveProps.resolveProps(start, {
           flow: fcName,
           indicator: "explicit-key-ind",
-          next: key ?? sep2?.[0],
+          next: key ?? sep3?.[0],
           offset,
           onError,
           parentIndent: fc.indent,
           startOnNewline: false
         });
         if (!props.found) {
-          if (!props.anchor && !props.tag && !sep2 && !value) {
+          if (!props.anchor && !props.tag && !sep3 && !value) {
             if (i === 0 && props.comma)
               onError(props.comma, "UNEXPECTED_TOKEN", `Unexpected , in ${fcName}`);
             else if (i < fc.items.length - 1)
@@ -4254,8 +4254,8 @@ var require_resolve_flow_collection = __commonJS({
             }
           }
         }
-        if (!isMap && !sep2 && !props.found) {
-          const valueNode = value ? composeNode(ctx, value, props, onError) : composeEmptyNode(ctx, props.end, sep2, null, props, onError);
+        if (!isMap && !sep3 && !props.found) {
+          const valueNode = value ? composeNode(ctx, value, props, onError) : composeEmptyNode(ctx, props.end, sep3, null, props, onError);
           coll.items.push(valueNode);
           offset = valueNode.range[2];
           if (isBlock(value))
@@ -4267,7 +4267,7 @@ var require_resolve_flow_collection = __commonJS({
           if (isBlock(key))
             onError(keyNode.range, "BLOCK_IN_FLOW", blockMsg);
           ctx.atKey = false;
-          const valueProps = resolveProps.resolveProps(sep2 ?? [], {
+          const valueProps = resolveProps.resolveProps(sep3 ?? [], {
             flow: fcName,
             indicator: "map-value-ind",
             next: value,
@@ -4278,8 +4278,8 @@ var require_resolve_flow_collection = __commonJS({
           });
           if (valueProps.found) {
             if (!isMap && !props.found && ctx.options.strict) {
-              if (sep2)
-                for (const st of sep2) {
+              if (sep3)
+                for (const st of sep3) {
                   if (st === valueProps.found)
                     break;
                   if (st.type === "newline") {
@@ -4296,7 +4296,7 @@ var require_resolve_flow_collection = __commonJS({
             else
               onError(valueProps.start, "MISSING_CHAR", `Missing , or : between ${fcName} items`);
           }
-          const valueNode = value ? composeNode(ctx, value, valueProps, onError) : valueProps.found ? composeEmptyNode(ctx, valueProps.end, sep2, null, valueProps, onError) : null;
+          const valueNode = value ? composeNode(ctx, value, valueProps, onError) : valueProps.found ? composeEmptyNode(ctx, valueProps.end, sep3, null, valueProps, onError) : null;
           if (valueNode) {
             if (isBlock(value))
               onError(valueNode.range, "BLOCK_IN_FLOW", blockMsg);
@@ -4476,7 +4476,7 @@ var require_resolve_block_scalar = __commonJS({
           chompStart = i + 1;
       }
       let value = "";
-      let sep2 = "";
+      let sep3 = "";
       let prevMoreIndented = false;
       for (let i = 0; i < contentStart; ++i)
         value += lines[i][0].slice(trimIndent) + "\n";
@@ -4493,24 +4493,24 @@ var require_resolve_block_scalar = __commonJS({
           indent = "";
         }
         if (type === Scalar.Scalar.BLOCK_LITERAL) {
-          value += sep2 + indent.slice(trimIndent) + content;
-          sep2 = "\n";
+          value += sep3 + indent.slice(trimIndent) + content;
+          sep3 = "\n";
         } else if (indent.length > trimIndent || content[0] === "	") {
-          if (sep2 === " ")
-            sep2 = "\n";
-          else if (!prevMoreIndented && sep2 === "\n")
-            sep2 = "\n\n";
-          value += sep2 + indent.slice(trimIndent) + content;
-          sep2 = "\n";
+          if (sep3 === " ")
+            sep3 = "\n";
+          else if (!prevMoreIndented && sep3 === "\n")
+            sep3 = "\n\n";
+          value += sep3 + indent.slice(trimIndent) + content;
+          sep3 = "\n";
           prevMoreIndented = true;
         } else if (content === "") {
-          if (sep2 === "\n")
+          if (sep3 === "\n")
             value += "\n";
           else
-            sep2 = "\n";
+            sep3 = "\n";
         } else {
-          value += sep2 + content;
-          sep2 = " ";
+          value += sep3 + content;
+          sep3 = " ";
           prevMoreIndented = false;
         }
       }
@@ -4692,25 +4692,25 @@ var require_resolve_flow_scalar = __commonJS({
       if (!match)
         return source;
       let res = match[1];
-      let sep2 = " ";
+      let sep3 = " ";
       let pos = first.lastIndex;
       line.lastIndex = pos;
       while (match = line.exec(source)) {
         if (match[1] === "") {
-          if (sep2 === "\n")
-            res += sep2;
+          if (sep3 === "\n")
+            res += sep3;
           else
-            sep2 = "\n";
+            sep3 = "\n";
         } else {
-          res += sep2 + match[1];
-          sep2 = " ";
+          res += sep3 + match[1];
+          sep3 = " ";
         }
         pos = line.lastIndex;
       }
       const last = /[ \t]*(.*)/sy;
       last.lastIndex = pos;
       match = last.exec(source);
-      return res + sep2 + (match?.[1] ?? "");
+      return res + sep3 + (match?.[1] ?? "");
     }
     function doubleQuotedValue(source, onError) {
       let res = "";
@@ -5511,14 +5511,14 @@ var require_cst_stringify = __commonJS({
         }
       }
     }
-    function stringifyItem({ start, key, sep: sep2, value }) {
+    function stringifyItem({ start, key, sep: sep3, value }) {
       let res = "";
       for (const st of start)
         res += st.source;
       if (key)
         res += stringifyToken(key);
-      if (sep2)
-        for (const st of sep2)
+      if (sep3)
+        for (const st of sep3)
           res += st.source;
       if (value)
         res += stringifyToken(value);
@@ -6667,18 +6667,18 @@ var require_parser = __commonJS({
         if (this.type === "map-value-ind") {
           const prev = getPrevProps(this.peek(2));
           const start = getFirstKeyStartProps(prev);
-          let sep2;
+          let sep3;
           if (scalar.end) {
-            sep2 = scalar.end;
-            sep2.push(this.sourceToken);
+            sep3 = scalar.end;
+            sep3.push(this.sourceToken);
             delete scalar.end;
           } else
-            sep2 = [this.sourceToken];
+            sep3 = [this.sourceToken];
           const map = {
             type: "block-map",
             offset: scalar.offset,
             indent: scalar.indent,
-            items: [{ start, key: scalar, sep: sep2 }]
+            items: [{ start, key: scalar, sep: sep3 }]
           };
           this.onKeyLine = true;
           this.stack[this.stack.length - 1] = map;
@@ -6831,15 +6831,15 @@ var require_parser = __commonJS({
                 } else if (isFlowToken(it.key) && !includesToken(it.sep, "newline")) {
                   const start2 = getFirstKeyStartProps(it.start);
                   const key = it.key;
-                  const sep2 = it.sep;
-                  sep2.push(this.sourceToken);
+                  const sep3 = it.sep;
+                  sep3.push(this.sourceToken);
                   delete it.key;
                   delete it.sep;
                   this.stack.push({
                     type: "block-map",
                     offset: this.offset,
                     indent: this.indent,
-                    items: [{ start: start2, key, sep: sep2 }]
+                    items: [{ start: start2, key, sep: sep3 }]
                   });
                 } else if (start.length > 0) {
                   it.sep = it.sep.concat(start, this.sourceToken);
@@ -7033,13 +7033,13 @@ var require_parser = __commonJS({
             const prev = getPrevProps(parent);
             const start = getFirstKeyStartProps(prev);
             fixFlowSeqItems(fc);
-            const sep2 = fc.end.splice(1, fc.end.length);
-            sep2.push(this.sourceToken);
+            const sep3 = fc.end.splice(1, fc.end.length);
+            sep3.push(this.sourceToken);
             const map = {
               type: "block-map",
               offset: fc.offset,
               indent: fc.indent,
-              items: [{ start, key: fc, sep: sep2 }]
+              items: [{ start, key: fc, sep: sep3 }]
             };
             this.onKeyLine = true;
             this.stack[this.stack.length - 1] = map;
@@ -7325,13 +7325,13 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // ../core/dist/config.js
-var import_node_os = require("node:os");
 var import_node_path2 = require("node:path");
 
 // ../core/dist/file-utils.js
 var import_node_crypto = require("node:crypto");
 var fs = __toESM(require("node:fs"), 1);
 var fsPromises = __toESM(require("node:fs/promises"), 1);
+var import_node_os = require("node:os");
 var import_node_path = require("node:path");
 var name1 = "read";
 var name2 = "File";
@@ -7344,6 +7344,12 @@ function getFileContentSync(path, encoding = "utf-8") {
 function getFileContentRaw(path) {
   return fsPromises[name1 + name2](path);
 }
+function getProcEnv() {
+  return process["env"];
+}
+function getHomeDir() {
+  return getProcEnv().HOME || (0, import_node_os.homedir)();
+}
 async function atomicWriteJson(path, data) {
   await fsPromises.mkdir((0, import_node_path.dirname)(path), { recursive: true });
   const tmp = `${path}.${(0, import_node_crypto.randomBytes)(6).toString("hex")}.tmp`;
@@ -11441,6 +11447,7 @@ var SeveritySchema = external_exports.enum(["critical", "high", "medium", "low"]
 var ActionSchema = external_exports.enum(["block", "require_approval", "log"]);
 var ThreatSchema = external_exports.object({
   id: external_exports.string(),
+  version: external_exports.number().int().optional(),
   category: external_exports.string(),
   severity: SeveritySchema,
   confidence: external_exports.number(),
@@ -11489,6 +11496,21 @@ var PackageCheckConfigSchema = external_exports.object({
 var AmsiCheckConfigSchema = external_exports.object({
   enabled: external_exports.boolean().default(true)
 });
+var ExceptionDecisionSchema = external_exports.enum(["allow", "deny"]);
+var ExceptionMatchSchema = external_exports.enum(["executable", "domain", "path", "plugin", "regex"]);
+var ExceptionRuleSchema = external_exports.object({
+  id: external_exports.string().optional(),
+  decision: ExceptionDecisionSchema,
+  match: ExceptionMatchSchema,
+  pattern: external_exports.string(),
+  reason: external_exports.string().optional()
+});
+var ExceptionsFileSchema = external_exports.object({
+  rules: external_exports.array(ExceptionRuleSchema).default([])
+});
+var ExceptionsConfigSchema = external_exports.object({
+  path: external_exports.string().default("~/.sage/exceptions.json")
+});
 var ConfigSchema = external_exports.object({
   url_check: UrlCheckConfigSchema.default({}),
   file_check: FileCheckConfigSchema.default({}),
@@ -11497,10 +11519,19 @@ var ConfigSchema = external_exports.object({
   heuristics_enabled: external_exports.boolean().default(true),
   cache: CacheConfigSchema.default({}),
   allowlist: AllowlistConfigSchema.default({}),
+  exceptions: ExceptionsConfigSchema.default({}),
   logging: LoggingConfigSchema.default({}),
   sensitivity: SensitivitySchema.default("balanced"),
   disabled_threats: external_exports.array(external_exports.string()).default([])
 });
+var HookTypeSchema = external_exports.enum([
+  "PreToolUse",
+  "PostToolUse",
+  "SessionStart",
+  "GatewayStart",
+  "BeforeAgentStart",
+  "MessagesTransform"
+]);
 
 // ../core/dist/config.js
 var SAGE_DIR = "~/.sage";
@@ -11516,12 +11547,16 @@ function defaultCachePath() {
 function defaultAllowlistPath() {
   return (0, import_node_path2.join)(resolvedSageDir(), "allowlist.json");
 }
+function defaultExceptionsPath() {
+  return (0, import_node_path2.join)(resolvedSageDir(), "exceptions.json");
+}
 function defaultAuditPath() {
   return (0, import_node_path2.join)(resolvedSageDir(), "audit.jsonl");
 }
 function resolvePath(pathStr) {
   if (pathStr.startsWith("~/") || pathStr === "~") {
-    return (0, import_node_path2.join)((0, import_node_os.homedir)(), pathStr.slice(1));
+    const home = getHomeDir();
+    return (0, import_node_path2.join)(home, pathStr.slice(1));
   }
   return pathStr;
 }
@@ -11564,6 +11599,7 @@ function normalizeStateFilePath(configuredPath, fallbackPath, field, logger) {
 function sanitizeConfigPaths(config, logger) {
   const cachePath = defaultCachePath();
   const allowlistPath = defaultAllowlistPath();
+  const exceptionsPath = defaultExceptionsPath();
   const auditPath = defaultAuditPath();
   return {
     ...config,
@@ -11575,6 +11611,10 @@ function sanitizeConfigPaths(config, logger) {
       ...config.allowlist,
       path: normalizeStateFilePath(config.allowlist.path, allowlistPath, "allowlist", logger)
     },
+    exceptions: {
+      ...config.exceptions,
+      path: normalizeStateFilePath(config.exceptions.path, exceptionsPath, "exceptions", logger)
+    },
     logging: {
       ...config.logging,
       path: normalizeStateFilePath(config.logging.path, auditPath, "logging", logger)
@@ -11610,7 +11650,6 @@ async function loadConfig(configPath, logger = nullLogger) {
 
 // ../core/dist/url-utils.js
 var import_node_crypto2 = require("node:crypto");
-var import_node_os2 = require("node:os");
 var import_node_path3 = require("node:path");
 function normalizeUrl(raw) {
   try {
@@ -11626,7 +11665,8 @@ function hashCommand(command) {
   return (0, import_node_crypto2.createHash)("sha256").update(command).digest("hex");
 }
 function normalizeFilePath(raw) {
-  const expanded = raw.startsWith("~/") || raw === "~" ? `${(0, import_node_os2.homedir)()}${raw.slice(1)}` : raw;
+  const home = getHomeDir();
+  const expanded = raw.startsWith("~/") || raw === "~" ? `${home}${raw.slice(1)}` : raw;
   return (0, import_node_path3.normalize)(expanded);
 }
 
@@ -11634,16 +11674,6 @@ function normalizeFilePath(raw) {
 function emptyAllowlist() {
   return { urls: {}, commands: {}, filePaths: {} };
 }
-function addEntry(record, key, reason, originalVerdict) {
-  record[key] = { addedAt: (/* @__PURE__ */ new Date()).toISOString(), reason, originalVerdict };
-}
-function removeEntry(record, key) {
-  if (key in record) {
-    delete record[key];
-    return true;
-  }
-  return false;
-}
 function parseEntries(raw) {
   const entries = {};
   for (const [key, entryData] of Object.entries(raw)) {
@@ -11696,29 +11726,6 @@ async function loadAllowlist(config, logger = nullLogger) {
     filePaths
   };
 }
-async function saveAllowlist(allowlist, config, logger = nullLogger) {
-  const path = resolvePath(config.path);
-  const serializeEntries = (entries) => Object.fromEntries(Object.entries(entries).map(([key, entry]) => [
-    key,
-    {
-      added_at: entry.addedAt,
-      reason: entry.reason,
-      original_verdict: entry.originalVerdict
-    }
-  ]));
-  const data = {
-    urls: serializeEntries(allowlist.urls),
-    commands: serializeEntries(allowlist.commands),
-    file_paths: serializeEntries(allowlist.filePaths)
-  };
-  try {
-    await atomicWriteJson(path, data);
-    return true;
-  } catch (e) {
-    logger.warn(`Failed to save allowlist to ${path}`, { error: String(e) });
-    return false;
-  }
-}
 function isAllowlisted(allowlist, artifacts) {
   for (const artifact of artifacts) {
     if (artifact.type !== "command") {
@@ -11742,24 +11749,6 @@ function isAllowlisted(allowlist, artifacts) {
   }
   return false;
 }
-function addUrl(allowlist, url, reason, originalVerdict) {
-  addEntry(allowlist.urls, normalizeUrl(url), reason, originalVerdict);
-}
-function addCommand(allowlist, command, reason, originalVerdict) {
-  addEntry(allowlist.commands, hashCommand(command), reason, originalVerdict);
-}
-function addFilePath(allowlist, filePath, reason, originalVerdict) {
-  addEntry(allowlist.filePaths, normalizeFilePath(filePath), reason, originalVerdict);
-}
-function removeFilePath(allowlist, filePath) {
-  return removeEntry(allowlist.filePaths, normalizeFilePath(filePath));
-}
-function removeUrl(allowlist, url) {
-  return removeEntry(allowlist.urls, normalizeUrl(url));
-}
-function removeCommand(allowlist, commandHash) {
-  return removeEntry(allowlist.commands, commandHash);
-}
 
 // ../core/dist/approval-store.js
 var import_node_crypto3 = require("node:crypto");
@@ -11853,6 +11842,7 @@ var ApprovalStore = class _ApprovalStore {
 };
 
 // ../core/dist/audit-log.js
+var import_node_crypto4 = require("node:crypto");
 var import_promises = require("node:fs/promises");
 var import_node_path4 = require("node:path");
 var MAX_SUMMARY_LEN = 200;
@@ -11902,15 +11892,19 @@ async function appendEntry(config, entry) {
   await (0, import_promises.appendFile)(path, `${JSON.stringify(entry)}
 `);
 }
-async function logVerdict(config, sessionId, toolName, toolInput, verdict, userOverride = false) {
+async function logVerdict(config, sessionId, toolName, toolInput, verdict, userOverride = false, conversationId, agentRuntime, hookType, signals) {
   if (!config.enabled)
     return;
   if (verdict.decision === "allow" && !config.log_clean && !userOverride)
     return;
   const entry = {
     type: "runtime_verdict",
+    entry_id: (0, import_node_crypto4.randomUUID)(),
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     session_id: sessionId,
+    conversation_id: conversationId ?? sessionId,
+    agent_runtime: agentRuntime,
+    hook_type: hookType,
     tool_name: toolName,
     tool_input_summary: toolInputSummary(toolName, toolInput),
     artifacts: verdict.artifacts,
@@ -11918,7 +11912,8 @@ async function logVerdict(config, sessionId, toolName, toolInput, verdict, userO
     severity: verdict.severity,
     reasons: verdict.reasons,
     source: verdict.source,
-    user_override: userOverride
+    user_override: userOverride,
+    signals
   };
   try {
     await appendEntry(config, entry);
@@ -12578,16 +12573,15 @@ var AmsiClient = class {
 };
 
 // ../core/dist/version.js
-var import_node_fs = require("node:fs");
 var import_node_path5 = require("node:path");
 var import_node_url = require("node:url");
 var import_meta = {};
 function resolveVersion() {
   if (true)
-    return "0.6.0";
+    return "0.7.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((0, import_node_fs.readFileSync)(pkgPath, "utf-8"));
+    const pkg = JSON.parse(getFileContentSync(pkgPath));
     if (typeof pkg.version === "string")
       return pkg.version;
   } catch {
@@ -12965,9 +12959,13 @@ var UrlCheckClient = class {
       const result = answer.result ?? {};
       const success = result.success ?? {};
       const classification = success.classification ?? {};
+      const detectionInfos = classification["detection-infos"] ?? [];
       const classResult = classification.result ?? {};
       const flags = success.flags ?? [];
       const malicious = classResult.malicious;
+      const detections = detectionInfos.filter((info) => typeof info.name === "string").map((info) => {
+        return info.name;
+      });
       const findings = malicious ? (malicious.findings ?? []).map((f) => ({
         severityName: f["severity-name"] ?? "unknown",
         typeName: f["type-name"] ?? "unknown"
@@ -12975,6 +12973,7 @@ var UrlCheckClient = class {
       return {
         url,
         isMalicious: Boolean(malicious),
+        detections,
         findings,
         flags
       };
@@ -13184,6 +13183,405 @@ var DecisionEngine = class {
   }
 };
 
+// ../core/dist/exceptions.js
+var import_node_crypto5 = require("node:crypto");
+var import_node_path7 = require("node:path");
+
+// ../core/dist/trusted-domains.js
+var import_promises2 = require("node:fs/promises");
+var import_node_path6 = require("node:path");
+var import_yaml = __toESM(require_dist(), 1);
+async function loadTrustedDomains(allowlistsDir, logger = nullLogger) {
+  let files;
+  try {
+    files = (await (0, import_promises2.readdir)(allowlistsDir)).filter((f) => f.endsWith(".yaml")).sort();
+  } catch {
+    logger.debug("Allowlists directory does not exist", { path: allowlistsDir });
+    return [];
+  }
+  const domains = [];
+  for (const filename of files) {
+    const filePath = (0, import_node_path6.join)(allowlistsDir, filename);
+    let content;
+    try {
+      content = await getFileContent(filePath);
+    } catch (e) {
+      logger.warn(`Failed to read ${filename}`, { error: String(e) });
+      continue;
+    }
+    let data;
+    try {
+      data = (0, import_yaml.parse)(content);
+    } catch (e) {
+      logger.warn(`Failed to parse ${filename}`, { error: String(e) });
+      continue;
+    }
+    if (!Array.isArray(data)) {
+      logger.warn(`Expected list in ${filename}, got ${typeof data}`);
+      continue;
+    }
+    for (const entry of data) {
+      if (typeof entry !== "object" || entry === null) {
+        logger.warn(`Skipping non-object entry in ${filename}`);
+        continue;
+      }
+      const record = entry;
+      const domain = record.domain;
+      const reason = record.reason;
+      if (!domain || typeof domain !== "string") {
+        logger.warn(`Skipping entry without valid 'domain' in ${filename}`);
+        continue;
+      }
+      if (!reason || typeof reason !== "string") {
+        logger.warn(`Skipping entry without valid 'reason' in ${filename}`);
+        continue;
+      }
+      domains.push({ domain: domain.toLowerCase(), reason });
+    }
+  }
+  logger.debug(`Loaded ${domains.length} trusted domains from ${allowlistsDir}`);
+  return domains;
+}
+function extractDomain(url) {
+  try {
+    const parsed = new URL(url);
+    return parsed.hostname.toLowerCase() || null;
+  } catch {
+    return null;
+  }
+}
+function isTrustedDomain(domain, trusted) {
+  const domainLower = domain.toLowerCase();
+  for (const td of trusted) {
+    if (domainLower === td.domain)
+      return true;
+    if (domainLower.endsWith(`.${td.domain}`))
+      return true;
+  }
+  return false;
+}
+
+// ../core/dist/exceptions.js
+var MAX_RULES_WARNING = 100;
+var REGEX_TIMEOUT_MS = 50;
+function computeRuleId(decision, match, pattern) {
+  const hash = (0, import_node_crypto5.createHash)("sha256").update(`${decision}:${match}:${pattern}`).digest("hex");
+  return hash.slice(0, 8);
+}
+async function loadExceptions(config, logger = nullLogger) {
+  const path = resolvePath(config.path);
+  let raw;
+  try {
+    raw = await getFileContent(path);
+  } catch {
+    return [];
+  }
+  let data;
+  try {
+    data = JSON.parse(raw);
+  } catch (e) {
+    logger.warn(`Failed to parse exceptions from ${path}`, { error: String(e) });
+    return [];
+  }
+  let parsed;
+  try {
+    parsed = ExceptionsFileSchema.parse(data);
+  } catch (e) {
+    logger.warn(`Exceptions validation failed for ${path}`, { error: String(e) });
+    return [];
+  }
+  if (parsed.rules.length > MAX_RULES_WARNING) {
+    logger.warn(`Exceptions file has ${parsed.rules.length} rules (>${MAX_RULES_WARNING})`, {
+      path
+    });
+  }
+  const seen = /* @__PURE__ */ new Map();
+  let needsWrite = false;
+  for (const rule of parsed.rules) {
+    const expectedId = computeRuleId(rule.decision, rule.match, rule.pattern);
+    if (rule.id !== expectedId) {
+      needsWrite = true;
+    }
+    if (seen.has(expectedId)) {
+      needsWrite = true;
+      continue;
+    }
+    const normalized = {
+      id: expectedId,
+      decision: rule.decision,
+      match: rule.match,
+      pattern: rule.pattern,
+      ...rule.reason !== void 0 ? { reason: rule.reason } : {}
+    };
+    seen.set(expectedId, normalized);
+  }
+  const rules = [...seen.values()];
+  if (needsWrite) {
+    try {
+      await atomicWriteJson(path, {
+        rules: rules.map((r) => ({
+          id: r.id,
+          decision: r.decision,
+          match: r.match,
+          pattern: r.pattern,
+          ...r.reason !== void 0 ? { reason: r.reason } : {}
+        }))
+      });
+    } catch (e) {
+      logger.warn(`Failed to write normalized exceptions to ${path}`, { error: String(e) });
+    }
+  }
+  for (const rule of rules) {
+    if (rule.match === "regex") {
+      try {
+        new RegExp(rule.pattern);
+      } catch (e) {
+        logger.warn(`Invalid regex in exception rule ${rule.id}: ${rule.pattern}`, {
+          error: String(e)
+        });
+      }
+    }
+  }
+  return rules;
+}
+var UNSAFE_COMMAND_PATTERN = /[;&|`]|\$\(|<\(|>\(|\n|\r/;
+var SUDO_FLAGS_WITH_ARG = /* @__PURE__ */ new Set(["-u", "-g", "-C", "-D", "-R", "-T", "-h", "-p"]);
+function matchesExecutable(pattern, command) {
+  if (UNSAFE_COMMAND_PATTERN.test(command)) {
+    return false;
+  }
+  const tokens = command.trim().split(/\s+/);
+  if (tokens.length === 0)
+    return false;
+  let i = 0;
+  if (tokens[i] === "sudo") {
+    i++;
+    while (i < tokens.length) {
+      const token = tokens[i];
+      if (token === void 0 || token === "--") {
+        if (token === "--")
+          i++;
+        break;
+      }
+      if (!token.startsWith("-"))
+        break;
+      i++;
+      const nextToken = tokens[i];
+      if (SUDO_FLAGS_WITH_ARG.has(token) && nextToken !== void 0 && !nextToken.startsWith("-")) {
+        i++;
+      }
+    }
+  }
+  if (i < tokens.length && tokens[i] === "env") {
+    i++;
+    while (i < tokens.length) {
+      const tok = tokens[i];
+      if (tok === void 0 || !/^\w+=/.test(tok))
+        break;
+      i++;
+    }
+  }
+  const exeToken = tokens[i];
+  if (exeToken === void 0)
+    return false;
+  const exeParts = exeToken.split("/");
+  const exeName = exeParts[exeParts.length - 1];
+  if (!exeName)
+    return false;
+  const patternTokens = pattern.trim().split(/\s+/);
+  if (patternTokens.length === 0)
+    return false;
+  if (exeName !== patternTokens[0])
+    return false;
+  for (let j = 1; j < patternTokens.length; j++) {
+    if (i + j >= tokens.length)
+      return false;
+    if (tokens[i + j] !== patternTokens[j])
+      return false;
+  }
+  return true;
+}
+function matchesDomain(pattern, url) {
+  const domain = extractDomain(url);
+  if (!domain)
+    return false;
+  const portMatch = pattern.match(/^(.+):(\d+)$/);
+  const portDomain = portMatch?.[1];
+  const portPort = portMatch?.[2];
+  if (portDomain && portPort) {
+    const patternDomain = portDomain.toLowerCase();
+    const patternPort = portPort;
+    let urlPort;
+    try {
+      const parsed = new URL(url);
+      urlPort = parsed.port || (parsed.protocol === "https:" ? "443" : "80");
+    } catch {
+      return false;
+    }
+    if (urlPort !== patternPort)
+      return false;
+    return isTrustedDomain(domain, [{ domain: patternDomain, reason: "" }]);
+  }
+  return isTrustedDomain(domain, [{ domain: pattern.toLowerCase(), reason: "" }]);
+}
+function normalizePatternPath(pattern) {
+  const home = getHomeDir();
+  const expanded = pattern.startsWith("~/") || pattern === "~" ? `${home}${pattern.slice(1)}` : pattern;
+  return (0, import_node_path7.normalize)(expanded);
+}
+function matchesPath(pattern, filePath) {
+  const hasWildcard = pattern.includes("*");
+  if (hasWildcard) {
+    return globMatch(normalizePatternPath(pattern), normalizePatternPath(filePath));
+  }
+  const normalizedPattern = normalizePatternPath(pattern);
+  const normalizedPath = normalizePatternPath(filePath);
+  if (normalizedPath === normalizedPattern)
+    return true;
+  if (normalizedPath.startsWith(normalizedPattern + import_node_path7.sep))
+    return true;
+  return false;
+}
+function matchesPlugin(pattern, pluginKey) {
+  const hasWildcard = pattern.includes("*");
+  if (hasWildcard) {
+    return globMatch(pattern, pluginKey);
+  }
+  if (pluginKey === pattern)
+    return true;
+  if (pluginKey.startsWith(pattern) && pluginKey[pattern.length] === "@")
+    return true;
+  return false;
+}
+function matchesRegex(pattern, value) {
+  let re;
+  try {
+    re = new RegExp(pattern);
+  } catch {
+    return false;
+  }
+  const start = performance.now();
+  try {
+    const result = re.test(value);
+    if (performance.now() - start > REGEX_TIMEOUT_MS) {
+      return false;
+    }
+    return result;
+  } catch {
+    return false;
+  }
+}
+function globMatch(pattern, value) {
+  const normPattern = pattern.replace(/\\/g, "/");
+  const normValue = value.replace(/\\/g, "/");
+  const regexStr = globToRegex(normPattern);
+  try {
+    const re = new RegExp(`^${regexStr}$`);
+    return re.test(normValue);
+  } catch {
+    return false;
+  }
+}
+function globToRegex(pattern) {
+  let result = "";
+  let i = 0;
+  while (i < pattern.length) {
+    const ch = pattern[i];
+    if (ch === void 0)
+      break;
+    if (ch === "*" && pattern[i + 1] === "*") {
+      result += ".*";
+      i += 2;
+      if (i < pattern.length && pattern[i] === "/")
+        i++;
+    } else if (ch === "*") {
+      result += "[^/]*";
+      i++;
+    } else if (ch === "?") {
+      result += "[^/]";
+      i++;
+    } else {
+      result += escapeRegex(ch);
+      i++;
+    }
+  }
+  return result;
+}
+function escapeRegex(char) {
+  return char.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function findDenyException(rules, artifacts) {
+  const denyRules = rules.filter((r) => r.decision === "deny");
+  for (const artifact of artifacts) {
+    for (const rule of denyRules) {
+      if (matchesArtifact(rule, artifact)) {
+        return { rule, artifact };
+      }
+    }
+  }
+  return null;
+}
+function findAllowException(rules, artifacts) {
+  const allowRules = rules.filter((r) => r.decision === "allow");
+  const execRules = allowRules.filter((r) => r.match === "executable");
+  if (execRules.length > 0) {
+    for (const artifact of artifacts) {
+      if (artifact.type !== "command")
+        continue;
+      const match = execRules.find((r) => matchesExecutable(r.pattern, artifact.value));
+      if (match)
+        return match;
+    }
+  }
+  const pathRules = allowRules.filter((r) => r.match === "path");
+  if (pathRules.length > 0) {
+    for (const artifact of artifacts) {
+      if (artifact.type !== "file_path")
+        continue;
+      const match = pathRules.find((r) => matchesPath(r.pattern, artifact.value));
+      if (match)
+        return match;
+    }
+  }
+  const domainRules = allowRules.filter((r) => r.match === "domain");
+  const firstDomainRule = domainRules[0];
+  if (firstDomainRule && artifacts.length > 0 && artifacts.every((a) => a.type === "url")) {
+    if (artifacts.every((a) => domainRules.some((r) => matchesDomain(r.pattern, a.value)))) {
+      return firstDomainRule;
+    }
+  }
+  const regexRules = allowRules.filter((r) => r.match === "regex");
+  const firstRegexRule = regexRules[0];
+  if (firstRegexRule && artifacts.length > 0) {
+    if (artifacts.every((a) => regexRules.some((r) => matchesRegex(r.pattern, a.value)))) {
+      return firstRegexRule;
+    }
+  }
+  return null;
+}
+function findPluginDenyException(rules, pluginKey) {
+  const found = rules.find((r) => r.decision === "deny" && r.match === "plugin" && matchesPlugin(r.pattern, pluginKey));
+  return found ?? null;
+}
+function findPluginAllowException(rules, pluginKey) {
+  const found = rules.find((r) => r.decision === "allow" && r.match === "plugin" && matchesPlugin(r.pattern, pluginKey));
+  return found ?? null;
+}
+function matchesArtifact(rule, artifact) {
+  switch (rule.match) {
+    case "executable":
+      return artifact.type === "command" && matchesExecutable(rule.pattern, artifact.value);
+    case "domain":
+      return artifact.type === "url" && matchesDomain(rule.pattern, artifact.value);
+    case "path":
+      return artifact.type === "file_path" && matchesPath(rule.pattern, artifact.value);
+    case "regex":
+      return matchesRegex(rule.pattern, artifact.value);
+    case "plugin":
+      return false;
+  }
+}
+
 // ../core/dist/extractors.js
 var URL_PATTERN = /https?:\/\/[^\s"')<>[\]{}]+/g;
 var TRAILING_PUNCT = /[.,;:!?]+$/;
@@ -13270,80 +13668,6 @@ function extractFromEdit(toolInput) {
   return extractFileArtifacts(toolInput, "file_path", "new_string", "edit", "from_edit_content");
 }
 
-// ../core/dist/trusted-domains.js
-var import_promises2 = require("node:fs/promises");
-var import_node_path6 = require("node:path");
-var import_yaml = __toESM(require_dist(), 1);
-async function loadTrustedDomains(allowlistsDir, logger = nullLogger) {
-  let files;
-  try {
-    files = (await (0, import_promises2.readdir)(allowlistsDir)).filter((f) => f.endsWith(".yaml")).sort();
-  } catch {
-    logger.debug("Allowlists directory does not exist", { path: allowlistsDir });
-    return [];
-  }
-  const domains = [];
-  for (const filename of files) {
-    const filePath = (0, import_node_path6.join)(allowlistsDir, filename);
-    let content;
-    try {
-      content = await getFileContent(filePath);
-    } catch (e) {
-      logger.warn(`Failed to read ${filename}`, { error: String(e) });
-      continue;
-    }
-    let data;
-    try {
-      data = (0, import_yaml.parse)(content);
-    } catch (e) {
-      logger.warn(`Failed to parse ${filename}`, { error: String(e) });
-      continue;
-    }
-    if (!Array.isArray(data)) {
-      logger.warn(`Expected list in ${filename}, got ${typeof data}`);
-      continue;
-    }
-    for (const entry of data) {
-      if (typeof entry !== "object" || entry === null) {
-        logger.warn(`Skipping non-object entry in ${filename}`);
-        continue;
-      }
-      const record = entry;
-      const domain = record.domain;
-      const reason = record.reason;
-      if (!domain || typeof domain !== "string") {
-        logger.warn(`Skipping entry without valid 'domain' in ${filename}`);
-        continue;
-      }
-      if (!reason || typeof reason !== "string") {
-        logger.warn(`Skipping entry without valid 'reason' in ${filename}`);
-        continue;
-      }
-      domains.push({ domain: domain.toLowerCase(), reason });
-    }
-  }
-  logger.debug(`Loaded ${domains.length} trusted domains from ${allowlistsDir}`);
-  return domains;
-}
-function extractDomain(url) {
-  try {
-    const parsed = new URL(url);
-    return parsed.hostname.toLowerCase() || null;
-  } catch {
-    return null;
-  }
-}
-function isTrustedDomain(domain, trusted) {
-  const domainLower = domain.toLowerCase();
-  for (const td of trusted) {
-    if (domainLower === td.domain)
-      return true;
-    if (domainLower.endsWith(`.${td.domain}`))
-      return true;
-  }
-  return false;
-}
-
 // ../core/dist/heuristics.js
 var TRUSTED_DOMAIN_SUPPRESSIBLE = /* @__PURE__ */ new Set([
   "CLT-CMD-001",
@@ -13486,7 +13810,9 @@ var PackageChecker = class {
               verdict: "malicious",
               confidence: 1,
               details: `Malicious package '${pkg.name}' (${detections})`,
-              fileCheckSeverity: sev
+              fileCheckSeverity: sev,
+              fileSha256: metadata.latestHash,
+              fileDetectionNames: fileResult.detectionNames
             };
           }
         }
@@ -13860,9 +14186,49 @@ function extractFromRequirementsTxt(content) {
   return packages;
 }
 
+// ../core/dist/statusline.js
+var import_node_path8 = require("node:path");
+var STATUS_PREFIX = "statusline-";
+var STATUS_SUFFIX = ".txt";
+function sanitizeSessionId(sessionId) {
+  return sessionId.replace(/[^a-zA-Z0-9-]/g, "_");
+}
+function statusFilePath(sessionId) {
+  return (0, import_node_path8.join)(resolvePath(SAGE_DIR), `${STATUS_PREFIX}${sanitizeSessionId(sessionId)}${STATUS_SUFFIX}`);
+}
+function emptyStatus() {
+  return {
+    denied: 0,
+    flagged: 0,
+    lastCategory: null,
+    lastReason: null,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+async function readStatus(sessionId) {
+  try {
+    const raw = await getFileContent(statusFilePath(sessionId), "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return emptyStatus();
+  }
+}
+async function updateSessionStatus(sessionId, verdict) {
+  const status = await readStatus(sessionId);
+  if (verdict.decision === "deny") {
+    status.denied++;
+  } else if (verdict.decision === "ask") {
+    status.flagged++;
+  }
+  status.lastCategory = verdict.category;
+  status.lastReason = verdict.reasons[0] ?? null;
+  status.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await atomicWriteJson(statusFilePath(sessionId), status);
+}
+
 // ../core/dist/threat-loader.js
 var import_promises3 = require("node:fs/promises");
-var import_node_path7 = require("node:path");
+var import_node_path9 = require("node:path");
 var import_yaml2 = __toESM(require_dist(), 1);
 var REQUIRED_FIELDS = /* @__PURE__ */ new Set([
   "id",
@@ -13900,7 +14266,7 @@ async function loadThreats(threatDir, logger = nullLogger) {
     return threats;
   }
   for (const filename of files) {
-    const filePath = (0, import_node_path7.join)(threatDir, filename);
+    const filePath = (0, import_node_path9.join)(threatDir, filename);
     let content;
     try {
       content = await getFileContent(filePath);
@@ -13949,6 +14315,7 @@ async function loadThreats(threatDir, logger = nullLogger) {
       const matchOn = new Set(Array.isArray(rawMatchOn) ? rawMatchOn : [rawMatchOn]);
       threats.push({
         id: record.id,
+        version: typeof record.version === "number" ? record.version : void 0,
         category: record.category,
         severity: record.severity,
         confidence: Number(record.confidence),
@@ -13986,12 +14353,45 @@ async function evaluateToolCall(request, context) {
     return allowVerdict("no_artifacts");
   }
   try {
-    const allowlist = await loadAllowlist(config.allowlist, logger);
-    if (isAllowlisted(allowlist, request.artifacts)) {
-      const verdict2 = allowVerdict("allowlisted");
-      await logVerdict(config.logging, request.sessionId, request.toolName, request.toolInput, verdict2, true);
+    const exceptions = await loadExceptions(config.exceptions, logger);
+    const denyMatch = findDenyException(exceptions, request.artifacts);
+    if (denyMatch) {
+      const verdict2 = {
+        decision: "deny",
+        category: "exception",
+        confidence: 1,
+        severity: "critical",
+        source: "exception",
+        artifacts: [denyMatch.artifact.value],
+        matchedThreatId: null,
+        reasons: [
+          `Deny exception: ${denyMatch.rule.match} pattern '${denyMatch.rule.pattern}'${denyMatch.rule.reason ? ` \u2014 ${denyMatch.rule.reason}` : ""}`
+        ]
+      };
+      try {
+        await logVerdict(config.logging, request.sessionId, request.toolName, request.toolInput, verdict2, false, request.conversationId, request.agentRuntime, request.hookType, void 0);
+      } catch {
+      }
       return verdict2;
     }
+    try {
+      const allowlist = await loadAllowlist(config.allowlist, logger);
+      if (isAllowlisted(allowlist, request.artifacts)) {
+        const allowV = allowVerdict("allowlisted");
+        await logVerdict(config.logging, request.sessionId, request.toolName, request.toolInput, allowV, true, request.conversationId, request.agentRuntime, request.hookType, void 0);
+        return allowV;
+      }
+    } catch {
+    }
+    const allowMatch = findAllowException(exceptions, request.artifacts);
+    if (allowMatch) {
+      const allowV = allowVerdict("exception");
+      try {
+        await logVerdict(config.logging, request.sessionId, request.toolName, request.toolInput, allowV, true, request.conversationId, request.agentRuntime, request.hookType, void 0);
+      } catch {
+      }
+      return allowV;
+    }
   } catch {
   }
   let cache = null;
@@ -14088,10 +14488,64 @@ async function evaluateToolCall(request, context) {
     }
   }
   await cacheUrlResults(urlCheckResults, cache);
+  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
+    }));
+  }
+  if (urlCheckResults.length > 0) {
+    const relevant = urlCheckResults.filter((r) => r.isMalicious || r.flags.length > 0);
+    if (relevant.length > 0) {
+      auditSignals.url_checks = relevant.flatMap((r) => {
+        return r.detections.map((d) => ({
+          detection_name: d,
+          url: r.url
+        }));
+      });
+    }
+  }
+  if (packageCheckResults.length > 0) {
+    const relevant = packageCheckResults.filter((p) => p.verdict !== "clean");
+    if (relevant.length > 0) {
+      auditSignals.package_checks = relevant.map((p) => ({
+        detection_name: formatPackageDetectionName(p),
+        package_name: p.packageName,
+        package_version: void 0,
+        package_registry: p.registry
+      }));
+    }
+    const fileRelevant = relevant.filter((p) => !!p.fileSha256 && (p.fileDetectionNames?.length ?? 0) > 0);
+    if (fileRelevant.length > 0) {
+      auditSignals.file_checks = fileRelevant.map((p) => ({
+        detection_name: (p.fileDetectionNames ?? []).join(","),
+        file_sha256: p.fileSha256
+      }));
+    }
+  }
   try {
-    await logVerdict(config.logging, request.sessionId, request.toolName, request.toolInput, verdict);
+    await logVerdict(config.logging, request.sessionId, request.toolName, request.toolInput, verdict, false, request.conversationId, request.agentRuntime, request.hookType, Object.keys(auditSignals).length > 0 ? auditSignals : void 0);
   } catch {
   }
+  if (verdict.decision !== "allow") {
+    try {
+      await updateSessionStatus(request.sessionId, verdict);
+    } catch {
+    }
+  }
   return verdict;
 }
 function partitionUrlsByCache(urls, cache) {
@@ -14349,76 +14803,14 @@ async function approveAction(store, actionId) {
     "Inform the user that they can ask you to permanently allowlist this artifact. Do NOT add it to the allowlist unless the user explicitly requests it."
   ].join("\n");
 }
-async function addToAllowlist(store, type, value, reason, configPath, logger = nullLogger) {
-  if (!store.hasApprovedArtifact(type, value)) {
-    return "Cannot add to allowlist: no recent user approval found for this artifact.";
-  }
-  const config = await loadConfig(configPath, logger);
-  const allowlist = await loadAllowlist(config.allowlist, logger);
-  const entryReason = reason ?? "Approved by user via sage_approve";
-  if (type === "url") {
-    addUrl(allowlist, value, entryReason, "ask");
-  } else if (type === "command") {
-    addCommand(allowlist, value, entryReason, "ask");
-  } else {
-    addFilePath(allowlist, value, entryReason, "ask");
-  }
-  const saved = await saveAllowlist(allowlist, config.allowlist, logger);
-  if (!saved) {
-    return "Failed to save allowlist. Approval preserved \u2014 retry is safe.";
-  }
-  store.consumeApprovedArtifact(type, value);
-  return `Added ${type} to Sage allowlist.`;
-}
-async function removeFromAllowlist(type, value, configPath, logger = nullLogger) {
-  const config = await loadConfig(configPath, logger);
-  const allowlist = await loadAllowlist(config.allowlist, logger);
-  let removed;
-  let removedViaHash = false;
-  switch (type) {
-    case "url":
-      removed = removeUrl(allowlist, value);
-      break;
-    case "command":
-      removed = removeCommand(allowlist, value);
-      if (!removed) {
-        removed = removeCommand(allowlist, hashCommand(value));
-        removedViaHash = true;
-      }
-      break;
-    case "file_path":
-      removed = removeFilePath(allowlist, value);
-      break;
-  }
-  if (!removed) {
-    return "Artifact not found in Sage allowlist.";
-  }
-  const saved = await saveAllowlist(allowlist, config.allowlist, logger);
-  if (!saved) {
-    return "Failed to save allowlist after removal. Please retry.";
-  }
-  let rendered;
-  switch (type) {
-    case "url":
-      rendered = normalizeUrl(value);
-      break;
-    case "command":
-      rendered = `${(removedViaHash ? hashCommand(value) : value).slice(0, 12)}...`;
-      break;
-    case "file_path":
-      rendered = normalizeFilePath(value);
-      break;
-  }
-  return `Removed ${type} from Sage allowlist: ${rendered}`;
-}
 
 // ../core/dist/installation-id.js
-var import_node_crypto4 = require("node:crypto");
+var import_node_crypto6 = require("node:crypto");
 var import_promises4 = require("node:fs/promises");
-var import_node_path8 = require("node:path");
+var import_node_path10 = require("node:path");
 async function getInstallationId(sageDirPath) {
   const sageDir = sageDirPath ?? resolvePath("~/.sage");
-  const idPath = (0, import_node_path8.join)(sageDir, "installation-id");
+  const idPath = (0, import_node_path10.join)(sageDir, "installation-id");
   let fileExists = false;
   try {
     const existing = await getFileContent(idPath, "utf-8");
@@ -14429,7 +14821,7 @@ async function getInstallationId(sageDirPath) {
   } catch {
   }
   try {
-    const id = (0, import_node_crypto4.randomUUID)();
+    const id = (0, import_node_crypto6.randomUUID)();
     await (0, import_promises4.mkdir)(sageDir, { recursive: true, mode: 448 });
     await (0, import_promises4.writeFile)(idPath, id, { encoding: "utf-8", mode: 384, flag: fileExists ? "w" : "wx" });
     return id;
@@ -14447,17 +14839,16 @@ async function getInstallationId(sageDirPath) {
 }
 
 // ../core/dist/plugin-scan-cache.js
-var import_node_crypto5 = require("node:crypto");
+var import_node_crypto7 = require("node:crypto");
 var import_promises5 = require("node:fs/promises");
-var import_node_os3 = require("node:os");
-var import_node_path9 = require("node:path");
-var DEFAULT_CACHE_PATH = (0, import_node_path9.join)((0, import_node_os3.homedir)(), ".sage", "plugin_scan_cache.json");
+var import_node_path11 = require("node:path");
+var DEFAULT_CACHE_PATH = (0, import_node_path11.join)(getHomeDir(), ".sage", "plugin_scan_cache.json");
 var CACHE_TTL_DAYS = 7;
 function cacheKey(pluginKey, version, lastUpdated) {
   return `${pluginKey}:${version}:${lastUpdated}`;
 }
 async function computeConfigHash(sageVersion, ...dirs) {
-  const h = (0, import_node_crypto5.createHash)("sha256");
+  const h = (0, import_node_crypto7.createHash)("sha256");
   if (sageVersion)
     h.update(sageVersion);
   for (const dir of dirs) {
@@ -14469,7 +14860,7 @@ async function computeConfigHash(sageVersion, ...dirs) {
     }
     for (const file of files) {
       try {
-        const content = await getFileContent((0, import_node_path9.join)(dir, file));
+        const content = await getFileContent((0, import_node_path11.join)(dir, file));
         h.update(content);
       } catch {
       }
@@ -14559,11 +14950,10 @@ function storeResult(cache, pluginKey, version, lastUpdated, findings) {
 }
 
 // ../core/dist/plugin-scanner.js
-var import_node_crypto6 = require("node:crypto");
+var import_node_crypto8 = require("node:crypto");
 var import_promises6 = require("node:fs/promises");
-var import_node_os4 = require("node:os");
-var import_node_path10 = require("node:path");
-var DEFAULT_PLUGINS_REGISTRY = (0, import_node_path10.join)((0, import_node_os4.homedir)(), ".claude", "plugins", "installed_plugins.json");
+var import_node_path12 = require("node:path");
+var DEFAULT_PLUGINS_REGISTRY = (0, import_node_path12.join)(getHomeDir(), ".claude", "plugins", "installed_plugins.json");
 var SCANNABLE_EXTENSIONS = /* @__PURE__ */ new Set([
   ".py",
   ".js",
@@ -14595,7 +14985,7 @@ async function walkPluginFiles(installPath, logger) {
       return;
     }
     if (stats.isFile()) {
-      if (SCANNABLE_EXTENSIONS.has((0, import_node_path10.extname)(dirOrFile).toLowerCase()) && stats.size <= MAX_FILE_SIZE) {
+      if (SCANNABLE_EXTENSIONS.has((0, import_node_path12.extname)(dirOrFile).toLowerCase()) && stats.size <= MAX_FILE_SIZE) {
         files.push(dirOrFile);
       }
       return;
@@ -14610,7 +15000,7 @@ async function walkPluginFiles(installPath, logger) {
       for (const entry of entries) {
         if (SKIP_DIRS.has(entry))
           continue;
-        const fullPath = (0, import_node_path10.join)(dirOrFile, entry);
+        const fullPath = (0, import_node_path12.join)(dirOrFile, entry);
         await walk(fullPath);
       }
     }
@@ -14712,7 +15102,7 @@ function extractArtifactsFromFile(filePath, content) {
       continue;
     artifacts.push({ type: "url", value: url, context: `plugin_file:${fileName}` });
   }
-  const ext = (0, import_node_path10.extname)(filePath).toLowerCase();
+  const ext = (0, import_node_path12.extname)(filePath).toLowerCase();
   if ([".sh", ".bash", ".zsh", ".py"].includes(ext)) {
     for (const line of content.split("\n")) {
       const trimmed = line.trim();
@@ -14760,7 +15150,7 @@ async function scanPlugin(plugin, threats, options = {}) {
           confidence: match.threat.confidence,
           action: match.threat.action,
           artifact: match.artifact.slice(0, 200),
-          sourceFile: (0, import_node_path10.relative)(plugin.installPath, filePath)
+          sourceFile: (0, import_node_path12.relative)(plugin.installPath, filePath)
         });
       }
     }
@@ -14768,7 +15158,7 @@ async function scanPlugin(plugin, threats, options = {}) {
       allUrls.push(...extractUrls(content));
     }
     if (checkFileHashes) {
-      const sha256 = (0, import_node_crypto6.createHash)("sha256").update(rawBytes).digest("hex");
+      const sha256 = (0, import_node_crypto8.createHash)("sha256").update(rawBytes).digest("hex");
       const existing = hashToFiles.get(sha256);
       if (existing) {
         existing.push(filePath);
@@ -14815,7 +15205,7 @@ async function scanPlugin(plugin, threats, options = {}) {
               confidence: 1,
               action: "block",
               artifact: fr.sha256,
-              sourceFile: (0, import_node_path10.relative)(plugin.installPath, filePath)
+              sourceFile: (0, import_node_path12.relative)(plugin.installPath, filePath)
             });
           }
         }
@@ -14827,6 +15217,37 @@ async function scanPlugin(plugin, threats, options = {}) {
   return result;
 }
 
+// ../core/dist/sage-proxy.js
+function mapSageProxyOs(platform) {
+  switch (platform) {
+    case "win32":
+      return "WINDOWS";
+    case "darwin":
+      return "MACOS";
+    case "linux":
+      return "LINUX";
+    default:
+      return platform;
+  }
+}
+function mapSageProxyArchitecture(arch) {
+  return arch.toUpperCase();
+}
+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)
+    },
+    agent: {
+      agent_runtime: args.agentRuntime,
+      agent_runtime_version: args.agentRuntimeVersion
+    }
+  };
+}
+
 // ../core/dist/session-start-scan.js
 function fromCachedFinding(finding) {
   return {
@@ -14865,11 +15286,39 @@ async function runSessionStartScan(context) {
   if (plugins.length === 0) {
     return [];
   }
+  let exceptions = [];
+  try {
+    const sageConfig = await loadConfig(context.configPath, logger);
+    exceptions = await loadExceptions(sageConfig.exceptions, logger);
+  } catch {
+  }
   const configHash = await computeConfigHash(context.sageVersion ?? "", context.threatsDir, context.allowlistsDir);
   const cache = await loadScanCache(configHash, context.scanCachePath, logger);
   const resultsWithFindings = [];
   let cacheModified = false;
   for (const plugin of plugins) {
+    const denyMatch = findPluginDenyException(exceptions, plugin.key);
+    if (denyMatch) {
+      resultsWithFindings.push({
+        plugin,
+        findings: [
+          {
+            threatId: "EXCEPTION-DENY",
+            title: `Denied by exception: ${denyMatch.pattern}${denyMatch.reason ? ` \u2014 ${denyMatch.reason}` : ""}`,
+            severity: "critical",
+            confidence: 1,
+            action: "block",
+            artifact: plugin.key,
+            sourceFile: "~/.sage/exceptions.json"
+          }
+        ]
+      });
+      continue;
+    }
+    const allowMatch = findPluginAllowException(exceptions, plugin.key);
+    if (allowMatch) {
+      continue;
+    }
     const cached = getCached(cache, plugin.key, plugin.version, plugin.lastUpdated);
     if (cached && cached.findings.length === 0) {
       continue;
@@ -14907,7 +15356,6 @@ async function runSessionStartScan(context) {
 }
 
 // ../core/dist/version-check.js
-var import_node_os5 = require("node:os");
 var DEFAULT_TIMEOUT_MS = 5e3;
 function isNewerVersion(current, latest) {
   const parse = (v) => v.replace(/^v/, "").split(".").map((n) => Number.parseInt(n, 10) || 0);
@@ -14929,22 +15377,23 @@ async function checkForUpdate(currentVersion, logger = nullLogger, timeoutMs = D
     return null;
   }
   try {
-    const response = await fetch(resolveEndpoint("/v1/version-check"), {
+    if (!context.iid) {
+      logger.debug("Skipping version check: missing installation id");
+      return null;
+    }
+    const response = await fetch(resolveEndpoint("/v2/version-check"), {
       method: "POST",
       signal: AbortSignal.timeout(timeoutMs),
       headers: {
         Accept: "application/json",
         "Content-Type": "application/json"
       },
-      body: JSON.stringify({
-        sage_version: currentVersion,
-        agent_runtime: context?.agentRuntime,
-        agent_runtime_version: context?.agentRuntimeVersion,
-        os: process.platform,
-        os_version: (0, import_node_os5.release)(),
-        arch: process.arch,
-        iid: context?.iid
-      })
+      body: JSON.stringify(buildSageProxyEnvelope({
+        iid: context.iid,
+        versionApp: currentVersion,
+        agentRuntime: context.agentRuntime,
+        agentRuntimeVersion: context.agentRuntimeVersion ?? "unknown"
+      }))
     });
     if (!response.ok) {
       logger.debug(`Version check HTTP ${response.status}`);
@@ -14986,11 +15435,16 @@ async function runSessionStart(ctx) {
       checkUrls: ctx.checkUrls,
       checkFileHashes: ctx.checkFileHashes
     }),
-    iidPromise.then((iid) => checkForUpdate(ctx.version, logger, void 0, {
-      agentRuntime: ctx.agentRuntime,
-      agentRuntimeVersion: ctx.agentRuntimeVersion,
-      iid
-    })).catch(() => null)
+    iidPromise.then((iid) => {
+      if (!iid) {
+        return null;
+      }
+      return checkForUpdate(ctx.version, logger, void 0, {
+        agentRuntime: ctx.agentRuntime,
+        agentRuntimeVersion: ctx.agentRuntimeVersion,
+        iid
+      });
+    }).catch(() => null)
   ]);
   return { scanResults, versionCheck };
 }
@@ -15029,78 +15483,20 @@ function createScanHandler(options) {
   };
 }
 
-// src/allowlist-tools.ts
-function createAllowlistAddTool(approvalStore, logger) {
-  return {
-    name: "sage_allowlist_add",
-    description: "Permanently allow a URL, command, or file path after recent user approval through Sage.",
-    parameters: {
-      type: "object",
-      properties: {
-        type: {
-          type: "string",
-          enum: ["url", "command", "file_path"],
-          description: "Artifact type"
-        },
-        value: {
-          type: "string",
-          description: "Exact URL, command, or file path to allowlist"
-        },
-        reason: {
-          type: "string",
-          description: "Optional reason for allowlist entry"
-        }
-      },
-      required: ["type", "value"]
-    },
-    async execute(_toolCallId, params) {
-      const { type, value, reason } = params;
-      const msg = await addToAllowlist(approvalStore, type, value, reason, void 0, logger);
-      return { content: [{ type: "text", text: msg }] };
-    }
-  };
-}
-function createAllowlistRemoveTool(logger) {
-  return {
-    name: "sage_allowlist_remove",
-    description: "Remove a URL, command, or file path from the Sage allowlist.",
-    parameters: {
-      type: "object",
-      properties: {
-        type: {
-          type: "string",
-          enum: ["url", "command", "file_path"],
-          description: "Artifact type"
-        },
-        value: {
-          type: "string",
-          description: "URL/file path, or command text/command hash for command entries"
-        }
-      },
-      required: ["type", "value"]
-    },
-    async execute(_toolCallId, params) {
-      const { type, value } = params;
-      const msg = await removeFromAllowlist(type, value, void 0, logger);
-      return { content: [{ type: "text", text: msg }] };
-    }
-  };
-}
-
 // src/bundled-dirs.ts
-var import_node_path11 = require("node:path");
-var packageRoot = (0, import_node_path11.resolve)(__dirname, "..");
+var import_node_path13 = require("node:path");
+var packageRoot = (0, import_node_path13.resolve)(__dirname, "..");
 function getBundledDataDirs() {
   return {
-    threatsDir: (0, import_node_path11.join)(packageRoot, "resources", "threats"),
-    allowlistsDir: (0, import_node_path11.join)(packageRoot, "resources", "allowlists")
+    threatsDir: (0, import_node_path13.join)(packageRoot, "resources", "threats"),
+    allowlistsDir: (0, import_node_path13.join)(packageRoot, "resources", "allowlists")
   };
 }
 var cachedVersion;
 function getSageVersion() {
   if (cachedVersion) return cachedVersion;
   try {
-    const pkg = JSON.parse(getFileContentSync((0, import_node_path11.join)(packageRoot, "package.json"), "utf-8"));
+    const pkg = JSON.parse(getFileContentSync((0, import_node_path13.join)(packageRoot, "package.json"), "utf-8"));
     cachedVersion = pkg.version ?? "0.0.0";
   } catch {
     cachedVersion = "0.0.0";
@@ -15165,9 +15561,9 @@ function createLogger(pluginLogger) {
 
 // src/plugin-discovery.ts
 var import_promises7 = require("node:fs/promises");
-var import_node_os6 = require("node:os");
-var import_node_path12 = require("node:path");
-var DEFAULT_EXTENSIONS_DIR = (0, import_node_path12.join)((0, import_node_os6.homedir)(), ".openclaw", "extensions");
+var import_node_os2 = require("node:os");
+var import_node_path14 = require("node:path");
+var DEFAULT_EXTENSIONS_DIR = (0, import_node_path14.join)((0, import_node_os2.homedir)(), ".openclaw", "extensions");
 async function discoverOpenClawPlugins(logger, extensionsDir = DEFAULT_EXTENSIONS_DIR) {
   logger.info("Sage plugin discovery: scanning extensions directory", { path: extensionsDir });
   let entries;
@@ -15179,7 +15575,7 @@ async function discoverOpenClawPlugins(logger, extensionsDir = DEFAULT_EXTENSION
   }
   const plugins = [];
   for (const entry of entries) {
-    const extDir = (0, import_node_path12.join)(extensionsDir, entry);
+    const extDir = (0, import_node_path14.join)(extensionsDir, entry);
     let stats;
     try {
       stats = await (0, import_promises7.stat)(extDir);
@@ -15189,7 +15585,7 @@ async function discoverOpenClawPlugins(logger, extensionsDir = DEFAULT_EXTENSION
     }
     let pkg;
     try {
-      const pkgPath = (0, import_node_path12.join)(extDir, "package.json");
+      const pkgPath = (0, import_node_path14.join)(extDir, "package.json");
       const raw = await getFileContent(pkgPath);
       pkg = JSON.parse(raw);
     } catch {
@@ -15293,7 +15689,14 @@ function createToolCallHandler(approvalStore, logger, threatsDir, allowlistsDir)
       if (!artifacts || artifacts.length === 0) return void 0;
       const sessionId = ctx?.sessionKey ?? "unknown";
       const { verdict, actionId } = await guardToolCall(
-        { sessionId, toolName, toolInput: params, artifacts },
+        {
+          sessionId,
+          conversationId: sessionId,
+          agentRuntime: "openclaw",
+          toolName,
+          toolInput: params,
+          artifacts
+        },
         { threatsDir, allowlistsDir, logger },
         approvalStore
       );
@@ -15338,10 +15741,6 @@ var index_default = {
       { priority: 100 }
     );
     api.registerTool(createSageApproveTool(approvalStore));
-    api.registerTool(
-      createAllowlistAddTool(approvalStore, logger)
-    );
-    api.registerTool(createAllowlistRemoveTool(logger));
     api.on("gateway_start", createStartupScanHandler(logger, onFindings));
     api.on("session_start", createSessionScanHandler(logger, onFindings));
     api.on(