@gendigital/sage-openclaw 0.9.0 → 0.10.0

package/dist/index.cjs

@@ -4233,7 +4233,7 @@ var init_zod = __esm({
 });
 
 // ../core/dist/types.js
-var nullLogger, ArtifactTypeSchema, ArtifactSchema, SeveritySchema, ActionSchema, ThreatSchema, DecisionSchema, VerdictSeveritySchema, SensitivitySchema, UrlCheckConfigSchema, CacheConfigSchema, AllowlistConfigSchema, LoggingConfigSchema, 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, SeveritySchema, ActionSchema, ThreatSchema, DecisionSchema, VerdictSeveritySchema, SensitivitySchema, UrlCheckConfigSchema, CacheConfigSchema, AllowlistConfigSchema, 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 init_types2 = __esm({
   "../core/dist/types.js"() {
     "use strict";
@@ -4293,6 +4293,14 @@ var init_types2 = __esm({
       max_bytes: external_exports.number().int().min(0).default(5 * 1024 * 1024),
       max_files: external_exports.number().int().min(0).default(3)
     });
+    OperationalLogLevelSchema = external_exports.enum(["debug", "info", "warn", "error"]);
+    OperationalLoggingConfigSchema = external_exports.object({
+      enabled: external_exports.boolean().default(true),
+      level: OperationalLogLevelSchema.default("info"),
+      path: external_exports.string().default("~/.sage/operational.jsonl"),
+      max_bytes: external_exports.number().int().min(0).default(5 * 1024 * 1024),
+      max_files: external_exports.number().int().min(0).default(3)
+    });
     FileCheckConfigSchema = external_exports.object({
       endpoint: external_exports.string().optional(),
       timeout_seconds: external_exports.number().default(5),
@@ -4342,6 +4350,7 @@ var init_types2 = __esm({
       allowlist: AllowlistConfigSchema.default({}),
       exceptions: ExceptionsConfigSchema.default({}),
       logging: LoggingConfigSchema.default({}),
+      operational_logging: OperationalLoggingConfigSchema.default({}),
       sensitivity: SensitivitySchema.default("balanced"),
       disabled_threats: external_exports.array(external_exports.string()).default([]),
       brand_key: external_exports.string().min(1).max(32).regex(/^[a-z0-9_-]+$/u).optional(),
@@ -4363,6 +4372,7 @@ var config_exports = {};
 __export(config_exports, {
   HOOK_TIMEOUT_SECONDS: () => HOOK_TIMEOUT_SECONDS,
   SAGE_DIR: () => SAGE_DIR,
+  defaultConfigPath: () => defaultConfigPath,
   loadConfig: () => loadConfig,
   loadConfigSync: () => loadConfigSync,
   resolvePath: () => resolvePath
@@ -4385,6 +4395,9 @@ function defaultExceptionsPath() {
 function defaultAuditPath() {
   return (0, import_node_path2.join)(resolvedSageDir(), "audit.jsonl");
 }
+function defaultOperationalLogPath() {
+  return (0, import_node_path2.join)(resolvedSageDir(), "operational.jsonl");
+}
 function resolvePath(pathStr) {
   if (pathStr.startsWith("~/") || pathStr === "~") {
     const home = getHomeDir();
@@ -4444,6 +4457,7 @@ function sanitizeConfigPaths(config2, logger) {
   const allowlistPath = defaultAllowlistPath();
   const exceptionsPath = defaultExceptionsPath();
   const auditPath = defaultAuditPath();
+  const operationalLogPath = defaultOperationalLogPath();
   return {
     ...config2,
     cache: {
@@ -4461,61 +4475,50 @@ function sanitizeConfigPaths(config2, logger) {
     logging: {
       ...config2.logging,
       path: normalizeStateFilePath(config2.logging.path, auditPath, "logging", logger)
+    },
+    operational_logging: {
+      ...config2.operational_logging,
+      path: normalizeStateFilePath(config2.operational_logging.path, operationalLogPath, "operational_logging", logger)
     }
   };
 }
-async function loadConfig(configPath, logger = nullLogger) {
-  const path = configPath ?? defaultConfigPath();
-  let raw;
-  try {
-    raw = await getFileContent(path);
-  } catch {
-    return sanitizeConfigPaths(ConfigSchema.parse({}), logger);
-  }
+function defaultConfig(logger) {
+  return sanitizeConfigPaths(ConfigSchema.parse({}), logger);
+}
+function parseConfig(raw, path, logger) {
   let data;
   try {
     data = JSON.parse(raw);
   } catch (e) {
     logger.warn(`Failed to parse config from ${path}`, { error: String(e) });
-    return sanitizeConfigPaths(ConfigSchema.parse({}), logger);
+    return defaultConfig(logger);
   }
   if (typeof data !== "object" || data === null || Array.isArray(data)) {
     logger.warn(`Config file ${path} does not contain a JSON object`);
-    return sanitizeConfigPaths(ConfigSchema.parse({}), logger);
+    return defaultConfig(logger);
   }
   const sanitized = sanitizeBrandKey(data, logger);
   try {
     return sanitizeConfigPaths(ConfigSchema.parse(sanitized), logger);
   } catch (e) {
     logger.warn(`Config validation failed, using defaults`, { error: String(e) });
-    return sanitizeConfigPaths(ConfigSchema.parse({}), logger);
+    return defaultConfig(logger);
   }
 }
-function loadConfigSync(configPath, logger = nullLogger) {
-  const path = configPath ?? defaultConfigPath();
-  let raw;
+async function loadConfig(configPath, logger = nullLogger) {
+  const path = configPath ? resolvePath(configPath) : defaultConfigPath();
   try {
-    raw = getFileContentSync(path);
+    return parseConfig(await getFileContent(path), path, logger);
   } catch {
-    return sanitizeConfigPaths(ConfigSchema.parse({}), logger);
-  }
-  let data;
-  try {
-    data = JSON.parse(raw);
-  } catch (e) {
-    logger.warn(`Failed to parse config from ${path}`, { error: String(e) });
-    return sanitizeConfigPaths(ConfigSchema.parse({}), logger);
+    return defaultConfig(logger);
   }
-  if (typeof data !== "object" || data === null || Array.isArray(data)) {
-    logger.warn(`Config file ${path} does not contain a JSON object`);
-    return sanitizeConfigPaths(ConfigSchema.parse({}), logger);
-  }
-  const sanitized = sanitizeBrandKey(data, logger);
+}
+function loadConfigSync(configPath, logger = nullLogger) {
+  const path = configPath ? resolvePath(configPath) : defaultConfigPath();
   try {
-    return sanitizeConfigPaths(ConfigSchema.parse(sanitized), logger);
-  } catch (e) {
-    logger.warn(`Config validation failed, using defaults`, { error: String(e) });
-    return sanitizeConfigPaths(ConfigSchema.parse({}), logger);
+    return parseConfig(getFileContentSync(path), path, logger);
+  } catch {
+    return defaultConfig(logger);
   }
 }
 var import_node_path2, SAGE_DIR, HOOK_TIMEOUT_SECONDS, BRAND_KEY_RE;
@@ -14229,7 +14232,7 @@ var ApprovalStore = class _ApprovalStore {
   approved = /* @__PURE__ */ new Map();
   static actionId(toolName, params, sessionId) {
     const payload = JSON.stringify({ toolName, params, sessionId });
-    return (0, import_node_crypto3.createHash)("sha256").update(payload).digest("hex");
+    return (0, import_node_crypto3.createHash)("sha256").update(payload).digest("hex").slice(0, 32);
   }
   static artifactId(type, value) {
     return `${type}:${value}`;
@@ -14237,6 +14240,9 @@ var ApprovalStore = class _ApprovalStore {
   setPending(actionId, entry) {
     this.pending.set(actionId, { ...entry, artifacts: [...entry.artifacts] });
   }
+  getPending(actionId) {
+    return this.pending.get(actionId) ?? null;
+  }
   deletePending(actionId) {
     this.pending.delete(actionId);
   }
@@ -14313,59 +14319,124 @@ var ApprovalStore = class _ApprovalStore {
 
 // ../core/dist/audit-log.js
 var import_node_crypto4 = require("node:crypto");
+init_config();
+init_file_utils();
+
+// ../core/dist/jsonl-log-writer.js
 var import_promises = require("node:fs/promises");
 var import_node_path4 = require("node:path");
+var import_promises2 = require("node:timers/promises");
 init_config();
-init_file_utils();
-var MAX_SUMMARY_LEN = 200;
-var AUDIT_LOG_SCHEMA_VERSION = 1;
-function toolInputSummary(toolName, toolInput) {
-  if (toolName === "Bash") {
-    return String(toolInput.command ?? "").slice(0, MAX_SUMMARY_LEN);
-  }
-  if (toolName === "WebFetch") {
-    return String(toolInput.url ?? "").slice(0, MAX_SUMMARY_LEN);
-  }
-  if (toolName === "Write" || toolName === "Edit" || toolName === "Read" || toolName === "Delete") {
-    return String(toolInput.file_path ?? "").slice(0, MAX_SUMMARY_LEN);
-  }
-  return JSON.stringify(toolInput).slice(0, MAX_SUMMARY_LEN);
-}
-async function rotateIfNeeded(filePath, maxBytes, maxFiles) {
+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;
-  let size;
+    return false;
   try {
     const s = await (0, import_promises.stat)(filePath);
-    size = s.size;
+    return s.size >= maxBytes;
   } catch {
-    return;
+    return false;
   }
-  if (size < maxBytes)
-    return;
+}
+async function removeStaleRotateLock(lockPath) {
   try {
-    await (0, import_promises.unlink)(`${filePath}.${maxFiles}`);
+    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 {
   }
-  for (let i = maxFiles - 1; i >= 1; i--) {
+}
+async function acquireRotateLock(filePath) {
+  const lockPath = `${filePath}.lock`;
+  const deadline = Date.now() + ROTATE_LOCK_TIMEOUT_MS;
+  while (true) {
     try {
-      await (0, import_promises.rename)(`${filePath}.${i}`, `${filePath}.${i + 1}`);
+      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 (0, import_promises.rename)(filePath, `${filePath}.1`);
-  } catch {
+    if (!await shouldRotate(filePath, maxBytes, maxFiles))
+      return;
+    try {
+      await (0, import_promises.unlink)(`${filePath}.${maxFiles}`);
+    } catch {
+    }
+    for (let i = maxFiles - 1; i >= 1; i--) {
+      try {
+        await (0, import_promises.rename)(`${filePath}.${i}`, `${filePath}.${i + 1}`);
+      } catch {
+      }
+    }
+    try {
+      await (0, import_promises.rename)(filePath, `${filePath}.1`);
+    } catch {
+    }
+  } finally {
+    await releaseLock();
   }
 }
-async function appendEntry(config2, entry) {
-  const path = resolvePath(config2.path);
+async function appendJsonlEntryNow(path, config2, entry) {
   await (0, import_promises.mkdir)((0, import_node_path4.dirname)(path), { recursive: true });
   await rotateIfNeeded(path, config2.max_bytes, config2.max_files);
-  const stamped = { ...entry, schema_version: AUDIT_LOG_SCHEMA_VERSION };
-  await (0, import_promises.appendFile)(path, `${JSON.stringify(stamped)}
+  await (0, import_promises.appendFile)(path, `${JSON.stringify(entry)}
 `);
 }
+async function appendJsonlEntry(config2, entry) {
+  const path = resolvePath(config2.path);
+  const previousWrite = writeQueues.get(path) ?? Promise.resolve();
+  const nextWrite = previousWrite.catch(() => {
+  }).then(() => appendJsonlEntryNow(path, config2, entry));
+  writeQueues.set(path, nextWrite);
+  try {
+    await nextWrite;
+  } finally {
+    if (writeQueues.get(path) === nextWrite)
+      writeQueues.delete(path);
+  }
+}
+
+// ../core/dist/audit-log.js
+var MAX_SUMMARY_LEN = 200;
+var AUDIT_LOG_SCHEMA_VERSION = 1;
+function toolInputSummary(toolName, toolInput) {
+  if (toolName === "Bash") {
+    return String(toolInput.command ?? "").slice(0, MAX_SUMMARY_LEN);
+  }
+  if (toolName === "WebFetch") {
+    return String(toolInput.url ?? "").slice(0, MAX_SUMMARY_LEN);
+  }
+  if (toolName === "Write" || toolName === "Edit" || toolName === "Read" || toolName === "Delete") {
+    return String(toolInput.file_path ?? "").slice(0, MAX_SUMMARY_LEN);
+  }
+  return JSON.stringify(toolInput).slice(0, MAX_SUMMARY_LEN);
+}
+async function appendEntry(config2, entry) {
+  const stamped = { ...entry, schema_version: AUDIT_LOG_SCHEMA_VERSION };
+  await appendJsonlEntry(config2, stamped);
+}
 async function logVerdict(config2, input) {
   if (!config2.enabled)
     return;
@@ -14873,6 +14944,7 @@ var PersistentPowershellAmsiBackend = class {
   logger;
   process = null;
   available = false;
+  invalidResultLogged = false;
   stdoutBuffer = "";
   pendingResponse = null;
   constructor(logger) {
@@ -14970,10 +15042,13 @@ var PersistentPowershellAmsiBackend = class {
       const line = await this.waitForLine(PS_TIMEOUT);
       const amsiResult = parseInt(line, 10);
       if (Number.isNaN(amsiResult) || amsiResult < 0) {
-        this.logger.warn("AMSI: PowerShell scan returned invalid result", {
-          stdout: line.slice(0, 100),
-          contentName
-        });
+        if (!this.invalidResultLogged) {
+          this.invalidResultLogged = true;
+          this.logger.warn("AMSI: PowerShell scan returned invalid result", {
+            stdout: line.slice(0, 100),
+            contentName
+          });
+        }
         return null;
       }
       this.logger.debug("AMSI: PowerShell scan result", { contentName, amsiResult });
@@ -15007,6 +15082,7 @@ var PersistentPowershellAmsiBackend = class {
 var WslPowershellAmsiBackend = class {
   logger;
   available = false;
+  invalidResultLogged = false;
   constructor(logger) {
     this.logger = logger;
   }
@@ -15050,10 +15126,13 @@ var WslPowershellAmsiBackend = class {
           clearTimeout(timer);
           const amsiResult = parseInt(stdout.trim(), 10);
           if (Number.isNaN(amsiResult) || amsiResult < 0) {
-            this.logger.warn("AMSI: PowerShell one-shot invalid result", {
-              stdout: stdout.slice(0, 100),
-              contentName
-            });
+            if (!this.invalidResultLogged) {
+              this.invalidResultLogged = true;
+              this.logger.warn("AMSI: PowerShell one-shot invalid result", {
+                stdout: stdout.slice(0, 100),
+                contentName
+              });
+            }
             resolve9(null);
             return;
           }
@@ -15212,7 +15291,7 @@ init_file_utils();
 var import_meta = {};
 function resolveVersion() {
   if (true)
-    return "0.9.0";
+    return "0.10.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));
@@ -15392,9 +15471,6 @@ function missingRequiredModels(schema = MODEL_SCHEMA_VERSION, sageDir) {
   const required = REQUIRED_MODELS_BY_SCHEMA[schema] ?? [];
   return required.filter((name) => !isModelPresent(name, schema, sageDir));
 }
-function anyRequiredModelMissing(schema = MODEL_SCHEMA_VERSION, sageDir) {
-  return missingRequiredModels(schema, sageDir).length > 0;
-}
 
 // ../core/dist/clients/model-downloader.js
 init_types2();
@@ -15763,9 +15839,11 @@ var BundledPiProvider = class _BundledPiProvider {
    * crash (exit code 134/SIGABRT). Only exits if the runtime was actually
    * loaded.
    */
-  static exitIfModelLoaded() {
-    if (_BundledPiProvider.modelRuntimeLoaded)
-      process.exit(0);
+  static async exitIfModelLoaded(logger) {
+    if (!_BundledPiProvider.modelRuntimeLoaded)
+      return;
+    await logger?.flush?.();
+    process.exit(0);
   }
   constructor(options = {}) {
     this.modelPath = options.modelPath ?? getModelDir("pi-model");
@@ -16029,6 +16107,75 @@ var SkillCheckClient = class {
 // ../core/dist/index.js
 init_config();
 
+// ../core/dist/config-diagnostics.js
+init_config();
+init_file_utils();
+init_types2();
+function formatPath(path) {
+  return path.replace(/\\/g, "/");
+}
+function configWarning(path, reason) {
+  return { file: "config", path, reason };
+}
+function exceptionsWarning(path, reason) {
+  return { file: "exceptions", path, reason };
+}
+function inspectConfig(raw, path) {
+  let data;
+  try {
+    data = JSON.parse(raw);
+  } catch {
+    return configWarning(path, "parse");
+  }
+  return ConfigSchema.safeParse(data).success ? null : configWarning(path, "validation");
+}
+function inspectExceptions(raw, path) {
+  let data;
+  try {
+    data = JSON.parse(raw);
+  } catch {
+    return exceptionsWarning(path, "parse");
+  }
+  return ExceptionsFileSchema.safeParse(data).success ? null : exceptionsWarning(path, "validation");
+}
+function getConfigurationWarningsSync(configPath, logger) {
+  const warnings = [];
+  const resolvedConfigPath = configPath ? resolvePath(configPath) : defaultConfigPath();
+  try {
+    const rawConfig = getFileContentSync(resolvedConfigPath);
+    const warning = inspectConfig(rawConfig, resolvedConfigPath);
+    if (warning)
+      warnings.push(warning);
+  } catch {
+  }
+  const config2 = loadConfigSync(resolvedConfigPath, logger);
+  const exceptionsPath = resolvePath(config2.exceptions.path);
+  try {
+    const rawExceptions = getFileContentSync(exceptionsPath);
+    const warning = inspectExceptions(rawExceptions, exceptionsPath);
+    if (warning)
+      warnings.push(warning);
+  } catch {
+  }
+  return warnings;
+}
+function formatConfigurationWarnings(warnings, branding2) {
+  if (warnings.length === 0)
+    return null;
+  const lines = [`\u26A0\uFE0F ${branding2.name}: configuration warning`];
+  for (const warning of warnings) {
+    if (warning.file === "config") {
+      const reason = warning.reason === "parse" ? "is not valid JSON" : "has the wrong shape";
+      lines.push(`- ${formatPath(warning.path)} ${reason}. ${branding2.short_name} is using default settings until this file is fixed.`);
+    } else if (warning.reason === "parse") {
+      lines.push(`- ${formatPath(warning.path)} is not valid JSON. Exception rules are not being applied until this file is fixed.`);
+    } else {
+      lines.push(`- ${formatPath(warning.path)} has the wrong shape. Expected ${JSON.stringify({ rules: [] })}. Exception rules are not being applied until this file is fixed.`);
+    }
+  }
+  return lines.join("\n");
+}
+
 // ../core/dist/content-policy.js
 var SCANNABLE_EXTENSIONS = /* @__PURE__ */ new Set([
   ".py",
@@ -16271,7 +16418,7 @@ function buildContentSnapshot(toolType, toolInput, artifacts = [], signals = {})
 }
 
 // ../core/dist/extended-info.js
-var import_promises2 = require("node:fs/promises");
+var import_promises3 = require("node:fs/promises");
 var import_node_os3 = require("node:os");
 var import_node_path10 = require("node:path");
 init_file_utils();
@@ -16285,6 +16432,23 @@ var cache = /* @__PURE__ */ new Map();
 function isPlainObjectValue(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function sanitizeScalarLeaf(leafValue) {
+  if (typeof leafValue === "string") {
+    return safeTruncate(leafValue, EXTENDED_INFO_MAX_LEAF_CHARS);
+  }
+  return leafValue;
+}
+function sanitizeArrayLeaf(groupKey, leafKey, items, logger) {
+  const out = [];
+  for (const [index, item] of items.entries()) {
+    if (typeof item !== "string" && typeof item !== "number" && typeof item !== "boolean") {
+      logger.debug(`extended-info: dropped non-scalar array item '${groupKey}.${leafKey}[${index}]' (type ${typeof item})`);
+      continue;
+    }
+    out.push(sanitizeScalarLeaf(item));
+  }
+  return out;
+}
 function sanitizeLeaves(groupKey, rawGroup, logger) {
   const entries = Object.entries(rawGroup);
   const overflow = entries.length > EXTENDED_INFO_MAX_KEYS_PER_GROUP;
@@ -16295,11 +16459,15 @@ function sanitizeLeaves(groupKey, rawGroup, logger) {
   const out = {};
   for (const [leafKey, leafValue] of retained) {
     if (typeof leafValue === "string") {
-      out[leafKey] = safeTruncate(leafValue, EXTENDED_INFO_MAX_LEAF_CHARS);
+      out[leafKey] = sanitizeScalarLeaf(leafValue);
       continue;
     }
     if (typeof leafValue === "number" || typeof leafValue === "boolean") {
-      out[leafKey] = leafValue;
+      out[leafKey] = sanitizeScalarLeaf(leafValue);
+      continue;
+    }
+    if (Array.isArray(leafValue)) {
+      out[leafKey] = sanitizeArrayLeaf(groupKey, leafKey, leafValue, logger);
       continue;
     }
     logger.debug(`extended-info: dropped non-scalar leaf '${groupKey}.${leafKey}' (type ${typeof leafValue})`);
@@ -16330,7 +16498,7 @@ async function loadExtendedInfo(sageDirPath, logger = nullLogger) {
 async function loadExtendedInfoUncached(filePath, logger) {
   let size;
   try {
-    const info = await (0, import_promises2.stat)(filePath);
+    const info = await (0, import_promises3.stat)(filePath);
     if (!info.isFile()) {
       logger.debug(`extended-info: not a regular file at ${filePath}`);
       return null;
@@ -16367,6 +16535,26 @@ async function loadExtendedInfoUncached(filePath, logger) {
   }
   return sanitizeDocument(parsed, logger);
 }
+function cloneExtendedInfoLeaf(leafValue) {
+  return Array.isArray(leafValue) ? dedupeArrayItems(leafValue) : leafValue;
+}
+function cloneExtendedInfoGroup(groupValue) {
+  return Object.fromEntries(Object.entries(groupValue).map(([leafKey, leafValue]) => [
+    leafKey,
+    cloneExtendedInfoLeaf(leafValue)
+  ]));
+}
+function dedupeArrayItems(items) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const item of items) {
+    if (seen.has(item))
+      continue;
+    seen.add(item);
+    out.push(item);
+  }
+  return out;
+}
 function mergeExtendedInfo(envelope, extendedInfo) {
   const out = { ...envelope };
   if (!extendedInfo)
@@ -16374,7 +16562,7 @@ function mergeExtendedInfo(envelope, extendedInfo) {
   for (const [groupKey, groupValue] of Object.entries(extendedInfo)) {
     const existing = out[groupKey];
     if (existing === void 0 || existing === null) {
-      out[groupKey] = { ...groupValue };
+      out[groupKey] = cloneExtendedInfoGroup(groupValue);
       continue;
     }
     if (!isPlainObjectValue(existing)) {
@@ -16384,7 +16572,11 @@ function mergeExtendedInfo(envelope, extendedInfo) {
     for (const [leafKey, leafValue] of Object.entries(groupValue)) {
       const current = merged[leafKey];
       if (current === void 0 || current === null) {
-        merged[leafKey] = leafValue;
+        merged[leafKey] = cloneExtendedInfoLeaf(leafValue);
+        continue;
+      }
+      if (Array.isArray(current) && Array.isArray(leafValue)) {
+        merged[leafKey] = dedupeArrayItems([...current, ...leafValue]);
       }
     }
     out[groupKey] = merged;
@@ -16394,7 +16586,7 @@ function mergeExtendedInfo(envelope, extendedInfo) {
 
 // ../core/dist/installation-id.js
 var import_node_crypto5 = require("node:crypto");
-var import_promises3 = require("node:fs/promises");
+var import_promises4 = require("node:fs/promises");
 var import_node_path11 = require("node:path");
 init_config();
 init_file_utils();
@@ -16412,8 +16604,8 @@ async function getInstallationId(sageDirPath) {
   }
   try {
     const id = (0, import_node_crypto5.randomUUID)();
-    await (0, import_promises3.mkdir)(sageDir, { recursive: true, mode: 448 });
-    await (0, import_promises3.writeFile)(idPath, id, { encoding: "utf-8", mode: 384, flag: fileExists ? "w" : "wx" });
+    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;
   } catch (err) {
     if (err.code === "EEXIST") {
@@ -16491,10 +16683,22 @@ async function sendCommunityIqDetection(args) {
       signal: AbortSignal.timeout(timeoutMs)
     });
     if (!response.ok) {
-      logger.debug(`Detection telemetry HTTP ${response.status}`);
+      logger.warn("Detection telemetry send failed", {
+        eventId: args.eventId,
+        status: response.status
+      });
+    } else {
+      logger.debug("Detection telemetry sent", {
+        eventId: args.eventId,
+        toolName: args.toolName,
+        hookType: args.hookType ?? "PreToolUse"
+      });
     }
   } catch (err) {
-    logger.debug(`Detection telemetry send failed: ${err}`);
+    logger.warn("Detection telemetry send failed", {
+      eventId: args.eventId,
+      error: String(err)
+    });
   }
 }
 
@@ -16758,7 +16962,7 @@ init_config();
 init_file_utils();
 
 // ../core/dist/trusted-domains.js
-var import_promises4 = require("node:fs/promises");
+var import_promises5 = require("node:fs/promises");
 var import_node_path12 = require("node:path");
 var import_yaml = __toESM(require_dist(), 1);
 init_file_utils();
@@ -16766,7 +16970,7 @@ init_types2();
 async function loadTrustedDomains(allowlistsDir, logger = nullLogger) {
   let files;
   try {
-    files = (await (0, import_promises4.readdir)(allowlistsDir)).filter((f) => f.endsWith(".yaml")).sort();
+    files = (await (0, import_promises5.readdir)(allowlistsDir)).filter((f) => f.endsWith(".yaml")).sort();
   } catch {
     logger.debug("Allowlists directory does not exist", { path: allowlistsDir });
     return [];
@@ -16937,8 +17141,14 @@ async function addException(artifact, reason, exceptionsPath, logger = nullLogge
     reason
   };
   const existing = await loadExceptions(excConfig, logger);
-  if (existing.some((r) => r.id === rule.id))
+  if (existing.some((r) => r.id === rule.id)) {
+    logger.debug("Exception rule already exists", {
+      ruleId: rule.id,
+      decision: rule.decision,
+      match: rule.match
+    });
     return;
+  }
   const rules = [...existing, rule];
   const path = resolvePath(excConfig.path);
   try {
@@ -16951,6 +17161,11 @@ async function addException(artifact, reason, exceptionsPath, logger = nullLogge
         ...r.reason !== void 0 ? { reason: r.reason } : {}
       }))
     });
+    logger.info("Exception rule added", {
+      ruleId: rule.id,
+      decision: rule.decision,
+      match: rule.match
+    });
   } catch (e) {
     logger.warn("Failed to write exception rule", { error: String(e) });
   }
@@ -17871,7 +18086,7 @@ async function updateSessionStatus(sessionId, verdict) {
 }
 
 // ../core/dist/threat-loader.js
-var import_promises5 = require("node:fs/promises");
+var import_promises6 = require("node:fs/promises");
 var import_node_path15 = require("node:path");
 var import_yaml2 = __toESM(require_dist(), 1);
 init_file_utils();
@@ -17906,7 +18121,7 @@ async function loadThreats(threatDir, logger = nullLogger) {
   const threats = [];
   let files;
   try {
-    files = (await (0, import_promises5.readdir)(threatDir)).filter((f) => f.endsWith(".yaml")).sort();
+    files = (await (0, import_promises6.readdir)(threatDir)).filter((f) => f.endsWith(".yaml")).sort();
   } catch {
     logger.warn("Threat directory does not exist or is unreadable", { path: threatDir });
     return threats;
@@ -17979,33 +18194,6 @@ async function loadThreats(threatDir, logger = nullLogger) {
   return threats;
 }
 
-// ../core/dist/tool-names.js
-var CANONICAL_TOOLS = [
-  "Bash",
-  "WebFetch",
-  "Write",
-  "Edit",
-  "Read",
-  "Delete",
-  "ApplyPatch",
-  "Glob",
-  "Grep",
-  "List",
-  "CodeSearch",
-  "WebSearch",
-  "Question",
-  "Task",
-  "ReadLines",
-  "MCP",
-  "Unknown"
-];
-var CANONICAL_SET = new Set(CANONICAL_TOOLS);
-function canonicalizeToolName(map, rawName) {
-  if (CANONICAL_SET.has(rawName))
-    return rawName;
-  return map[rawName] ?? "Unknown";
-}
-
 // ../core/dist/evaluator.js
 init_types2();
 var AMSI_CONTENT_SNIPPET_MAX = 200;
@@ -18046,11 +18234,43 @@ function allowVerdict(source = "none") {
     reasons: []
   };
 }
+function shouldSkipPromptInjectionForLocalMarkdown(request) {
+  if (request.toolName !== "Write" && request.toolName !== "Edit")
+    return false;
+  const filePath = resolveFilePath(request.toolInput) ?? "";
+  const trimmed = filePath.trim();
+  return /\.(?:md|mdx|markdown|mdown|mkdn)$/i.test(trimmed);
+}
 async function evaluateToolCall(request, context) {
   const logger = context.logger ?? nullLogger;
   const config2 = await loadConfig(context.configPath, logger).catch(() => ConfigSchema.parse({}));
+  const eventId = (0, import_node_crypto7.randomUUID)();
+  logger.debug("Tool call evaluation started", {
+    eventId,
+    toolUseId: request.toolUseId,
+    toolName: request.toolName,
+    hookType: request.hookType,
+    agentRuntime: request.agentRuntime,
+    artifactsCount: request.artifacts.length
+  });
+  const logEvaluationCompleted = (verdict2) => {
+    logger.debug("Tool call evaluation completed", {
+      eventId,
+      toolUseId: request.toolUseId,
+      toolName: request.toolName,
+      hookType: request.hookType,
+      agentRuntime: request.agentRuntime,
+      artifactsCount: request.artifacts.length,
+      decision: verdict2.decision,
+      source: verdict2.source,
+      category: verdict2.category,
+      severity: verdict2.severity
+    });
+  };
   if (request.artifacts.length === 0 && !config2.pi_check.enabled) {
-    return allowVerdict("no_artifacts");
+    const verdict2 = allowVerdict("no_artifacts");
+    logEvaluationCompleted(verdict2);
+    return verdict2;
   }
   try {
     const exceptions = await loadExceptions(config2.exceptions, logger);
@@ -18076,10 +18296,13 @@ async function evaluateToolCall(request, context) {
           verdict: verdict2,
           conversationId: request.conversationId,
           agentRuntime: request.agentRuntime,
-          hookType: request.hookType
+          hookType: request.hookType,
+          eventId,
+          toolUseId: request.toolUseId
         });
       } catch {
       }
+      logEvaluationCompleted(verdict2);
       return verdict2;
     }
     try {
@@ -18094,8 +18317,11 @@ async function evaluateToolCall(request, context) {
           userOverride: true,
           conversationId: request.conversationId,
           agentRuntime: request.agentRuntime,
-          hookType: request.hookType
+          hookType: request.hookType,
+          eventId,
+          toolUseId: request.toolUseId
         });
+        logEvaluationCompleted(allowV);
         return allowV;
       }
     } catch {
@@ -18112,19 +18338,24 @@ async function evaluateToolCall(request, context) {
           userOverride: true,
           conversationId: request.conversationId,
           agentRuntime: request.agentRuntime,
-          hookType: request.hookType
+          hookType: request.hookType,
+          eventId,
+          toolUseId: request.toolUseId
         });
       } catch {
       }
+      logEvaluationCompleted(allowV);
       return allowV;
     }
-  } catch {
+  } catch (error) {
+    logger.debug("Exception/allowlist checks failed open", { error: String(error) });
   }
   let cache2 = null;
   try {
     cache2 = new VerdictCache(config2.cache, logger, VERSION);
     await cache2.load();
-  } catch {
+  } catch (error) {
+    logger.debug("Verdict cache initialization failed open", { error: String(error) });
     cache2 = null;
   }
   const urls = request.artifacts.filter((artifact) => artifact.type === "url").map((artifact) => artifact.value);
@@ -18136,6 +18367,9 @@ async function evaluateToolCall(request, context) {
       const disabledSet = new Set(config2.disabled_threats);
       threats = threats.filter((t) => !disabledSet.has(t.id));
     }
+    if (shouldSkipPromptInjectionForLocalMarkdown(request)) {
+      threats = threats.filter((t) => t.category !== "prompt_injection");
+    }
     const trustedDomains = await loadTrustedDomains(context.allowlistsDir, logger);
     const heuristics = new HeuristicsEngine(threats, trustedDomains);
     heuristicMatches = heuristics.match(request.artifacts);
@@ -18339,7 +18573,6 @@ async function evaluateToolCall(request, context) {
       auditSignals.amsi_checks = relevantAmsi.map((r) => buildAmsiSignal(r));
     }
   }
-  const eventId = (0, import_node_crypto7.randomUUID)();
   const resolvedSignals = Object.keys(auditSignals).length > 0 ? auditSignals : void 0;
   const builtContent = buildContentSnapshot(request.toolName, request.toolInput, request.artifacts, auditSignals);
   const resolvedContent = Object.keys(builtContent).length > 0 ? builtContent : void 0;
@@ -18357,7 +18590,8 @@ async function evaluateToolCall(request, context) {
       eventId,
       toolUseId: request.toolUseId
     });
-  } catch {
+  } catch (error) {
+    logger.debug("Audit verdict logging failed open", { error: String(error) });
   }
   if (verdict.decision === "deny") {
     try {
@@ -18372,18 +18606,21 @@ async function evaluateToolCall(request, context) {
         communityIqEnabled: config2.community_iq,
         logger
       });
-    } catch {
+    } catch (error) {
+      logger.debug("Detection telemetry failed open", { error: String(error) });
     }
   }
   if (verdict.decision !== "allow") {
     try {
       await updateSessionStatus(request.sessionId, verdict);
-    } catch {
+    } catch (error) {
+      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);
   if (piWarnings.length > 0 && config2.sensitivity !== "relaxed")
     verdict.piWarnings = piWarnings;
+  logEvaluationCompleted(verdict);
   return verdict;
 }
 function partitionUrlsByCache(urls, cache2) {
@@ -18683,9 +18920,125 @@ init_config();
 // ../core/dist/model-download.js
 init_types2();
 
+// ../core/dist/operational-log.js
+var LEVEL_PRIORITY = {
+  debug: 10,
+  info: 20,
+  warn: 30,
+  error: 40
+};
+var FLUSH_TIMEOUT_MS = 250;
+function shouldLog(config2, level) {
+  return config2.enabled && LEVEL_PRIORITY[level] >= LEVEL_PRIORITY[config2.level];
+}
+function normalizeData(data) {
+  if (!data)
+    return void 0;
+  const seen = /* @__PURE__ */ new WeakSet();
+  try {
+    return JSON.parse(JSON.stringify(data, (_key, value) => {
+      if (typeof value === "bigint")
+        return value.toString();
+      if (value instanceof Error) {
+        return { name: value.name, message: value.message, stack: value.stack };
+      }
+      if (value && typeof value === "object") {
+        if (seen.has(value))
+          return "[Circular]";
+        seen.add(value);
+      }
+      return value;
+    }));
+  } catch {
+    return { serialization_error: "Failed to serialize log data" };
+  }
+}
+async function writeOperationalLogEntry(config2, entry) {
+  if (!shouldLog(config2, entry.level))
+    return;
+  try {
+    await appendJsonlEntry(config2, entry);
+  } catch {
+  }
+}
+function createOperationalLogger(config2, runtime) {
+  const pendingWrites = /* @__PURE__ */ new Set();
+  function log(component, level, message, data) {
+    if (!shouldLog(config2, level))
+      return;
+    const entry = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      level,
+      runtime,
+      component,
+      message,
+      ...data ? { data: normalizeData(data) } : {}
+    };
+    const write = writeOperationalLogEntry(config2, entry);
+    pendingWrites.add(write);
+    void write.finally(() => pendingWrites.delete(write));
+  }
+  async function flush() {
+    const deadline = Date.now() + FLUSH_TIMEOUT_MS;
+    while (pendingWrites.size > 0) {
+      const remainingMs = deadline - Date.now();
+      if (remainingMs <= 0)
+        return;
+      let timeout;
+      try {
+        const result = await Promise.race([
+          Promise.allSettled([...pendingWrites]).then(() => "drained"),
+          new Promise((resolve9) => {
+            timeout = setTimeout(() => resolve9("timeout"), remainingMs);
+            timeout.unref?.();
+          })
+        ]);
+        if (result === "timeout")
+          return;
+      } finally {
+        if (timeout)
+          clearTimeout(timeout);
+      }
+    }
+  }
+  function forComponent(component) {
+    return {
+      debug(msg, data) {
+        log(component, "debug", msg, data);
+      },
+      info(msg, data) {
+        log(component, "info", msg, data);
+      },
+      warn(msg, data) {
+        log(component, "warn", msg, data);
+      },
+      error(msg, data) {
+        log(component, "error", msg, data);
+      },
+      flush
+    };
+  }
+  return {
+    debug(component, msg, data) {
+      log(component, "debug", msg, data);
+    },
+    info(component, msg, data) {
+      log(component, "info", msg, data);
+    },
+    warn(component, msg, data) {
+      log(component, "warn", msg, data);
+    },
+    error(component, msg, data) {
+      log(component, "error", msg, data);
+    },
+    forComponent,
+    flush
+  };
+}
+
 // ../core/dist/plugin-scan-cache.js
 var import_node_crypto8 = require("node:crypto");
-var import_promises6 = require("node:fs/promises");
+var import_promises7 = require("node:fs/promises");
 var import_node_path16 = require("node:path");
 init_file_utils();
 init_types2();
@@ -18701,7 +19054,7 @@ async function computeConfigHash(sageVersion, ...dirs) {
   for (const dir of dirs) {
     let files;
     try {
-      files = (await (0, import_promises6.readdir)(dir)).filter((f) => f.endsWith(".yaml")).sort();
+      files = (await (0, import_promises7.readdir)(dir)).filter((f) => f.endsWith(".yaml")).sort();
     } catch {
       continue;
     }
@@ -18726,7 +19079,7 @@ async function loadScanCache(configHash = "", cachePath = DEFAULT_CACHE_PATH, lo
     const data = JSON.parse(raw);
     const storedHash = data.config_hash ?? "";
     if (configHash && storedHash !== configHash) {
-      logger.info("Config hash changed, invalidating plugin scan cache", {
+      logger.debug("Config hash changed, invalidating plugin scan cache", {
         from: storedHash,
         to: configHash
       });
@@ -18798,13 +19151,13 @@ function storeResult(cache2, pluginKey, version, lastUpdated, findings) {
 
 // ../core/dist/plugin-scanner.js
 var import_node_crypto10 = require("node:crypto");
-var import_promises8 = require("node:fs/promises");
+var import_promises9 = require("node:fs/promises");
 var import_node_path18 = require("node:path");
 init_file_utils();
 
 // ../core/dist/skill-id.js
 var import_node_crypto9 = require("node:crypto");
-var import_promises7 = require("node:fs/promises");
+var import_promises8 = require("node:fs/promises");
 var import_node_path17 = require("node:path");
 var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "__pycache__"]);
 function isContained(childReal, rootReal) {
@@ -18820,22 +19173,22 @@ function normalizePath(p) {
 }
 async function entriesFromDirectory(dirPath) {
   const absDir = (0, import_node_path17.resolve)(dirPath);
-  const rootReal = await (0, import_promises7.realpath)(absDir);
+  const rootReal = await (0, import_promises8.realpath)(absDir);
   const entries = [];
   const visited = /* @__PURE__ */ new Set();
   async function walk(currentPath) {
-    const real = await (0, import_promises7.realpath)(currentPath);
+    const real = await (0, import_promises8.realpath)(currentPath);
     if (visited.has(real))
       return;
     if (!isContained(real, rootReal))
       return;
     visited.add(real);
-    const items = await (0, import_promises7.readdir)(currentPath);
+    const items = await (0, import_promises8.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_promises7.stat)(fullPath);
+      const st = await (0, import_promises8.stat)(fullPath);
       if (st.isDirectory())
         dirs.push(item);
       else if (st.isFile())
@@ -18851,14 +19204,14 @@ async function entriesFromDirectory(dirPath) {
     }
     for (const f of files) {
       const fullPath = (0, import_node_path17.join)(currentPath, f);
-      const fileReal = await (0, import_promises7.realpath)(fullPath);
+      const fileReal = await (0, import_promises8.realpath)(fullPath);
       if (!isContained(fileReal, rootReal))
         continue;
       const relPath = (0, import_node_path17.relative)(absDir, fullPath).replace(/\\/g, "/");
       entries.push({
         entryPath: relPath,
         isDir: false,
-        content: await (0, import_promises7.readFile)(fullPath)
+        content: await (0, import_promises8.readFile)(fullPath)
       });
     }
   }
@@ -18899,10 +19252,10 @@ async function findSkillPackages(rootDir) {
   const found = [];
   let rootReal;
   try {
-    const rootStat = await (0, import_promises7.stat)(rootDir);
+    const rootStat = await (0, import_promises8.stat)(rootDir);
     if (!rootStat.isDirectory())
       return found;
-    rootReal = await (0, import_promises7.realpath)((0, import_node_path17.resolve)(rootDir));
+    rootReal = await (0, import_promises8.realpath)((0, import_node_path17.resolve)(rootDir));
   } catch {
     return found;
   }
@@ -18910,7 +19263,7 @@ async function findSkillPackages(rootDir) {
   async function walk(dir) {
     let real;
     try {
-      real = await (0, import_promises7.realpath)(dir);
+      real = await (0, import_promises8.realpath)(dir);
     } catch {
       return;
     }
@@ -18921,14 +19274,14 @@ async function findSkillPackages(rootDir) {
     visited.add(real);
     let items;
     try {
-      items = await (0, import_promises7.readdir)(dir);
+      items = await (0, import_promises8.readdir)(dir);
     } catch {
       return;
     }
     items.sort();
     if (items.includes("SKILL.md")) {
       try {
-        const st = await (0, import_promises7.stat)((0, import_node_path17.join)(dir, "SKILL.md"));
+        const st = await (0, import_promises8.stat)((0, import_node_path17.join)(dir, "SKILL.md"));
         if (st.isFile())
           found.push(dir);
       } catch {
@@ -18940,7 +19293,7 @@ async function findSkillPackages(rootDir) {
       const fullPath = (0, import_node_path17.join)(dir, item);
       let st;
       try {
-        st = await (0, import_promises7.stat)(fullPath);
+        st = await (0, import_promises8.stat)(fullPath);
       } catch {
         continue;
       }
@@ -18994,7 +19347,7 @@ async function walkPluginFiles(installPath, logger) {
   async function walk(dirOrFile) {
     let stats;
     try {
-      stats = await (0, import_promises8.stat)(dirOrFile);
+      stats = await (0, import_promises9.stat)(dirOrFile);
     } catch {
       return;
     }
@@ -19007,7 +19360,7 @@ async function walkPluginFiles(installPath, logger) {
     if (stats.isDirectory()) {
       let entries;
       try {
-        entries = await (0, import_promises8.readdir)(dirOrFile);
+        entries = await (0, import_promises9.readdir)(dirOrFile);
       } catch {
         return;
       }
@@ -19200,6 +19553,16 @@ async function runSessionStartScan(context) {
   const sageConfig = await loadConfig(context.configPath, logger);
   const plugins = context.plugins;
   if (plugins.length === 0) {
+    logger.debug("Session plugin scan completed", {
+      totalPlugins: 0,
+      resultsWithFindings: 0,
+      findingsCount: 0,
+      cacheHits: 0,
+      cacheMisses: 0,
+      scanned: 0,
+      allowedByException: 0,
+      deniedByException: 0
+    });
     return [];
   }
   let exceptions = [];
@@ -19232,9 +19595,21 @@ async function scanAllPlugins(context, config2, plugins, exceptions, amsiClient,
   const cache2 = await loadScanCache(configHash, context.scanCachePath, logger);
   const resultsWithFindings = [];
   let cacheModified = false;
+  const stats = {
+    totalPlugins: plugins.length,
+    cacheHitsClean: 0,
+    cacheHitsWithFindings: 0,
+    cacheMisses: 0,
+    scanned: 0,
+    allowedByException: 0,
+    deniedByException: 0,
+    findingsCount: 0
+  };
   for (const plugin of plugins) {
     const denyMatch = findPluginDenyException(exceptions, plugin.key);
     if (denyMatch) {
+      stats.deniedByException += 1;
+      stats.findingsCount += 1;
       resultsWithFindings.push({
         plugin,
         findings: [
@@ -19253,19 +19628,25 @@ async function scanAllPlugins(context, config2, plugins, exceptions, amsiClient,
     }
     const allowMatch = findPluginAllowException(exceptions, plugin.key);
     if (allowMatch) {
+      stats.allowedByException += 1;
       continue;
     }
     const cached = getCached(cache2, plugin.key, plugin.version, plugin.lastUpdated);
     if (cached && cached.findings.length === 0) {
+      stats.cacheHitsClean += 1;
       continue;
     }
     if (cached && cached.findings.length > 0) {
+      stats.cacheHitsWithFindings += 1;
+      stats.findingsCount += cached.findings.length;
       resultsWithFindings.push({
         plugin,
         findings: cached.findings.map(fromCachedFinding)
       });
       continue;
     }
+    stats.cacheMisses += 1;
+    stats.scanned += 1;
     const result = await scanPlugin(plugin, {
       checkUrls: context.checkUrls ?? true,
       checkFileHashes: context.checkFileHashes ?? true,
@@ -19275,6 +19656,7 @@ async function scanAllPlugins(context, config2, plugins, exceptions, amsiClient,
     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);
     }
   }
@@ -19287,6 +19669,11 @@ async function scanAllPlugins(context, config2, plugins, exceptions, amsiClient,
     }
   } catch {
   }
+  logger.debug("Session plugin scan completed", {
+    ...stats,
+    cacheHits: stats.cacheHitsClean + stats.cacheHitsWithFindings,
+    resultsWithFindings: resultsWithFindings.length
+  });
   return resultsWithFindings;
 }
 
@@ -19401,14 +19788,30 @@ async function runSessionStart(ctx) {
   return { scanResults, versionCheck };
 }
 async function maybeSpawnModelDownloadWorker(args) {
-  if (!args.workerPath)
+  if (!args.workerPath) {
+    args.logger.debug("Model download worker skipped", {
+      result: "skipped",
+      skippedReason: "missing_worker_path"
+    });
     return;
+  }
   if (!(0, import_node_fs4.existsSync)(args.workerPath)) {
-    args.logger.debug(`model download worker script not found at ${args.workerPath}`);
+    args.logger.debug("Model download worker skipped", {
+      result: "skipped",
+      skippedReason: "worker_script_not_found",
+      workerPath: args.workerPath
+    });
     return;
   }
-  if (!anyRequiredModelMissing(MODEL_SCHEMA_VERSION, args.sageDirPath))
+  const missingModels = missingRequiredModels(MODEL_SCHEMA_VERSION, args.sageDirPath);
+  if (missingModels.length === 0) {
+    args.logger.debug("Model download worker skipped", {
+      result: "skipped",
+      skippedReason: "no_missing_models",
+      schema: MODEL_SCHEMA_VERSION
+    });
     return;
+  }
   let piEnabled = false;
   try {
     const config2 = await loadConfig(args.configPath, args.logger);
@@ -19416,9 +19819,16 @@ async function maybeSpawnModelDownloadWorker(args) {
   } catch {
     piEnabled = false;
   }
-  if (!piEnabled)
+  if (!piEnabled) {
+    args.logger.debug("Model download worker skipped", {
+      result: "skipped",
+      skippedReason: "pi_check_disabled",
+      schema: MODEL_SCHEMA_VERSION,
+      missingModels
+    });
     return;
-  spawnModelDownloadWorker({
+  }
+  const spawned = spawnModelDownloadWorker({
     sageDirPath: args.sageDirPath,
     workerPath: args.workerPath,
     agentRuntime: args.agentRuntime,
@@ -19426,6 +19836,11 @@ async function maybeSpawnModelDownloadWorker(args) {
     versionApp: args.versionApp,
     logger: args.logger
   });
+  args.logger.debug("Model download worker spawn completed", {
+    result: spawned ? "spawned" : "failed",
+    schema: MODEL_SCHEMA_VERSION,
+    missingModels
+  });
 }
 function spawnModelDownloadWorker(args) {
   const logger = args.logger ?? nullLogger;
@@ -19443,14 +19858,18 @@ function spawnModelDownloadWorker(args) {
       }
     });
     child.unref();
+    return true;
   } catch (err) {
-    logger.debug(`failed to spawn model download worker: ${err}`);
+    logger.warn("Failed to spawn model download worker", { error: String(err) });
+    return false;
   }
 }
 
 // ../core/dist/scan-handler.js
 async function runPluginScan(logger, context, plugins, threatsDir, allowlistsDir, version, agentRuntime, branding2 = defaultBranding, modelDownloadWorkerPath, style = "verbose") {
-  logger.info(`${branding2.name} plugin scan started (${context})`, {
+  logger.debug(`${branding2.name} plugin scan started (${context})`, {
+    agentRuntime,
+    pluginsCount: plugins.length,
     threatsDir,
     allowlistsDir
   });
@@ -19463,10 +19882,19 @@ async function runPluginScan(logger, context, plugins, threatsDir, allowlistsDir
     agentRuntime,
     modelDownloadWorkerPath
   });
-  logger.info(`${branding2.name} plugin scan (${context}) complete`, {
-    findings: result.scanResults.length,
+  const findingsCount = result.scanResults.reduce((total, scanResult) => total + scanResult.findings.length, 0);
+  const completionData = {
+    agentRuntime,
+    pluginsCount: plugins.length,
+    resultsWithFindings: result.scanResults.length,
+    findingsCount,
     updateAvailable: result.versionCheck?.updateAvailable ?? false
-  });
+  };
+  if (findingsCount > 0) {
+    logger.warn(`${branding2.name} plugin scan (${context}) complete with findings`, completionData);
+  } else {
+    logger.debug(`${branding2.name} plugin scan (${context}) complete`, completionData);
+  }
   return formatSessionStartMessage(version, result, branding2, style);
 }
 function createScanHandler(options) {
@@ -19476,7 +19904,7 @@ function createScanHandler(options) {
       let plugins = await discoverPlugins2();
       plugins = plugins.filter((p) => !p.key.startsWith(selfPrefix));
       if (plugins.length === 0) {
-        logger.warn(`${branding2.name} plugin scan (${context}): no plugins to scan after filtering`);
+        logger.debug(`${branding2.name} plugin scan (${context}): no plugins to scan after filtering`);
       }
       const msg = await runPluginScan(logger, context, plugins, threatsDir, allowlistsDir, version, agentRuntime, branding2, modelDownloadWorkerPath, style);
       onResult?.(msg);
@@ -19486,6 +19914,33 @@ function createScanHandler(options) {
   };
 }
 
+// ../core/dist/tool-names.js
+var CANONICAL_TOOLS = [
+  "Bash",
+  "WebFetch",
+  "Write",
+  "Edit",
+  "Read",
+  "Delete",
+  "ApplyPatch",
+  "Glob",
+  "Grep",
+  "List",
+  "CodeSearch",
+  "WebSearch",
+  "Question",
+  "Task",
+  "ReadLines",
+  "MCP",
+  "Unknown"
+];
+var CANONICAL_SET = new Set(CANONICAL_TOOLS);
+function canonicalizeToolName(map, rawName) {
+  if (CANONICAL_SET.has(rawName))
+    return rawName;
+  return map[rawName] ?? "Unknown";
+}
+
 // ../core/dist/index.js
 init_types2();
 
@@ -19510,42 +19965,21 @@ function getSageVersion() {
   return cachedVersion;
 }
 
-// src/logger-adapter.ts
-function createLogger(pluginLogger) {
-  function formatMessage(msg, data) {
-    return data ? `${msg} ${JSON.stringify(data)}` : msg;
-  }
-  return {
-    debug(msg, data) {
-      pluginLogger.debug?.(formatMessage(msg, data));
-    },
-    info(msg, data) {
-      pluginLogger.info(formatMessage(msg, data));
-    },
-    warn(msg, data) {
-      pluginLogger.warn(formatMessage(msg, data));
-    },
-    error(msg, data) {
-      pluginLogger.error(formatMessage(msg, data));
-    }
-  };
-}
-
 // src/startup-scan.ts
 var import_node_path21 = require("node:path");
 
 // src/plugin-discovery.ts
-var import_promises9 = require("node:fs/promises");
+var import_promises10 = 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) {
-  logger.info(`${branding2.name} plugin discovery: scanning extensions directory`, {
+  logger.debug(`${branding2.name} plugin discovery: scanning extensions directory`, {
     path: extensionsDir
   });
   let entries;
   try {
-    entries = await (0, import_promises9.readdir)(extensionsDir);
+    entries = await (0, import_promises10.readdir)(extensionsDir);
   } catch {
     logger.debug("OpenClaw extensions directory not found", { path: extensionsDir });
     return [];
@@ -19555,7 +19989,7 @@ async function discoverOpenClawPlugins(logger, extensionsDir = DEFAULT_EXTENSION
     const extDir = (0, import_node_path20.join)(extensionsDir, entry);
     let stats;
     try {
-      stats = await (0, import_promises9.stat)(extDir);
+      stats = await (0, import_promises10.stat)(extDir);
       if (!stats.isDirectory()) continue;
     } catch {
       continue;
@@ -19583,7 +20017,7 @@ async function discoverOpenClawPlugins(logger, extensionsDir = DEFAULT_EXTENSION
       lastUpdated: stats.mtime.toISOString()
     });
   }
-  logger.info(`${branding2.name} plugin discovery: found ${plugins.length} extension(s)`);
+  logger.debug(`${branding2.name} plugin discovery: found ${plugins.length} extension(s)`);
   return plugins;
 }
 
@@ -19616,7 +20050,7 @@ function createBeforeAgentStartHandler(getFindings, clearFindings, logger, brand
     const findings = getFindings();
     if (!findings) return void 0;
     clearFindings();
-    logger.info(`${branding2.name}: surfacing plugin scan findings via before_agent_start`);
+    logger.debug(`${branding2.name}: surfacing plugin scan findings via before_agent_start`);
     const prependContext = [
       '<security-alert source="sage-plugin-scan">',
       findings,
@@ -19692,30 +20126,74 @@ function mapToolToArtifacts(toolName, params) {
 }
 function createToolCallHandler(approvalStore, logger, threatsDir, allowlistsDir, branding2 = defaultBranding) {
   async function handleToolCall(event, ctx) {
+    const sessionId = ctx?.sessionKey ?? "unknown";
+    const completeHook = (result, data = {}) => {
+      logger.debug("OpenClaw tool hook completed", {
+        agentRuntime: "openclaw",
+        hookType: "PreToolUse",
+        toolName: event.toolName,
+        sessionId,
+        result,
+        ...data
+      });
+    };
+    logger.debug("OpenClaw tool hook started", {
+      agentRuntime: "openclaw",
+      hookType: "PreToolUse",
+      toolName: event.toolName,
+      sessionId
+    });
     try {
       const { toolName, params } = event;
       const artifacts = mapToolToArtifacts(toolName, params);
-      if (!artifacts || artifacts.length === 0) return void 0;
-      const sessionId = ctx?.sessionKey ?? "unknown";
+      if (!artifacts || artifacts.length === 0) {
+        completeHook("skipped", { skippedReason: "no_artifacts" });
+        return void 0;
+      }
+      const canonicalToolName = canonicalizeToolName(OPENCLAW_TOOL_MAP, toolName);
       const { verdict, actionId } = await guardToolCall(
         {
           sessionId,
           conversationId: sessionId,
           agentRuntime: "openclaw",
-          toolName: canonicalizeToolName(OPENCLAW_TOOL_MAP, toolName),
+          toolName: canonicalToolName,
           toolInput: normalizeToolInput(toolName, params),
           artifacts
         },
         { threatsDir, allowlistsDir, logger },
         approvalStore
       );
-      if (verdict.decision === "allow") return void 0;
+      if (verdict.decision === "allow") {
+        completeHook("evaluated", {
+          toolName: canonicalToolName,
+          decision: verdict.decision,
+          category: verdict.category,
+          severity: verdict.severity,
+          artifactsCount: artifacts.length
+        });
+        return void 0;
+      }
       if (verdict.decision === "deny") {
+        completeHook("evaluated", {
+          toolName: canonicalToolName,
+          decision: verdict.decision,
+          category: verdict.category,
+          severity: verdict.severity,
+          artifactsCount: artifacts.length
+        });
         return { block: true, blockReason: formatDenyMessage(verdict, branding2) };
       }
       const reasons = verdict.reasons.length > 0 ? verdict.reasons.slice(0, 3).join("; ") : verdict.category;
       const intersected = artifacts.filter((a) => verdict.artifacts.includes(a.value));
       const flaggedArtifacts = intersected.length > 0 ? intersected : artifacts;
+      completeHook("evaluated", {
+        toolName: canonicalToolName,
+        decision: verdict.decision,
+        category: verdict.category,
+        severity: verdict.severity,
+        artifactsCount: artifacts.length,
+        actionId
+      });
       return {
         requireApproval: {
           id: actionId,
@@ -19729,7 +20207,14 @@ function createToolCallHandler(approvalStore, logger, threatsDir, allowlistsDir,
           timeoutBehavior: "deny",
           onResolution: async (decision) => {
             approvalStore.deletePending(actionId);
-            if (decision !== "allow-always") return;
+            if (decision !== "allow-always") {
+              logger.debug("OpenClaw approval resolved without persistent allow", {
+                actionId,
+                decision
+              });
+              return;
+            }
+            logger.info("OpenClaw approval accepted permanently", { actionId });
             for (const a of flaggedArtifacts) {
               await addException(
                 { type: a.type, value: a.value },
@@ -19743,6 +20228,7 @@ function createToolCallHandler(approvalStore, logger, threatsDir, allowlistsDir,
       };
     } catch (e) {
       logger.error("tool-handler error, failing open", { error: String(e) });
+      completeHook("failed_open", { decision: "allow" });
       return void 0;
     }
   }
@@ -19760,29 +20246,35 @@ var index_default = {
     jsonSchema: { type: "object", additionalProperties: false, properties: {} }
   },
   register(api) {
-    const logger = createLogger(api.logger);
+    const operationalLogger = createOperationalLogger(config.operational_logging, "openclaw");
+    const logger = operationalLogger.forComponent("plugin");
+    const toolLogger = operationalLogger.forComponent("tool-handler");
+    const scanLogger = operationalLogger.forComponent("startup-scan");
     const approvalStore = new ApprovalStore();
     const { threatsDir, allowlistsDir } = getBundledDataDirs();
     const CLEANUP_INTERVAL_MS = 5 * 60 * 1e3;
     const interval = setInterval(() => approvalStore.cleanup(), CLEANUP_INTERVAL_MS);
     if (typeof interval.unref === "function") interval.unref();
-    let pendingFindings = null;
+    let pendingConfigurationWarnings = formatConfigurationWarnings(getConfigurationWarningsSync(void 0, logger), branding) ?? null;
+    let pendingScanFindings = null;
     const onFindings = (msg) => {
-      pendingFindings = msg;
+      pendingScanFindings = msg;
     };
+    const getPendingFindings = () => [pendingConfigurationWarnings, pendingScanFindings].filter(Boolean).join("\n\n") || null;
     api.on(
       "before_tool_call",
-      createToolCallHandler(approvalStore, logger, threatsDir, allowlistsDir, branding),
+      createToolCallHandler(approvalStore, toolLogger, threatsDir, allowlistsDir, branding),
       { priority: 100 }
     );
-    api.on("gateway_start", createStartupScanHandler(logger, branding, onFindings));
-    api.on("session_start", createSessionScanHandler(logger, branding, onFindings));
+    api.on("gateway_start", createStartupScanHandler(scanLogger, branding, onFindings));
+    api.on("session_start", createSessionScanHandler(scanLogger, branding, onFindings));
     api.on(
       "before_agent_start",
       createBeforeAgentStartHandler(
-        () => pendingFindings,
+        getPendingFindings,
         () => {
-          pendingFindings = null;
+          pendingConfigurationWarnings = null;
+          pendingScanFindings = null;
         },
         logger,
         branding