eminiar 0.9.0 → 0.10.0

package/dist/hook.js

@@ -174,14 +174,14 @@ var require_is_extglob = __commonJS({
   "node_modules/is-extglob/index.js"(exports, module) {
     "use strict";
     init_esm_shims();
-    module.exports = function isExtglob(str) {
-      if (typeof str !== "string" || str === "") {
+    module.exports = function isExtglob(str2) {
+      if (typeof str2 !== "string" || str2 === "") {
         return false;
       }
       var match;
-      while (match = /(\\).|([@?!+*]\(.*\))/g.exec(str)) {
+      while (match = /(\\).|([@?!+*]\(.*\))/g.exec(str2)) {
         if (match[2]) return true;
-        str = str.slice(match.index + match[0].length);
+        str2 = str2.slice(match.index + match[0].length);
       }
       return false;
     };
@@ -195,8 +195,8 @@ var require_is_glob = __commonJS({
     init_esm_shims();
     var isExtglob = require_is_extglob();
     var chars = { "{": "}", "(": ")", "[": "]" };
-    var strictCheck = function(str) {
-      if (str[0] === "!") {
+    var strictCheck = function(str2) {
+      if (str2[0] === "!") {
         return true;
       }
       var index = 0;
@@ -205,70 +205,70 @@ var require_is_glob = __commonJS({
       var closeCurlyIndex = -2;
       var closeParenIndex = -2;
       var backSlashIndex = -2;
-      while (index < str.length) {
-        if (str[index] === "*") {
+      while (index < str2.length) {
+        if (str2[index] === "*") {
           return true;
         }
-        if (str[index + 1] === "?" && /[\].+)]/.test(str[index])) {
+        if (str2[index + 1] === "?" && /[\].+)]/.test(str2[index])) {
           return true;
         }
-        if (closeSquareIndex !== -1 && str[index] === "[" && str[index + 1] !== "]") {
+        if (closeSquareIndex !== -1 && str2[index] === "[" && str2[index + 1] !== "]") {
           if (closeSquareIndex < index) {
-            closeSquareIndex = str.indexOf("]", index);
+            closeSquareIndex = str2.indexOf("]", index);
           }
           if (closeSquareIndex > index) {
             if (backSlashIndex === -1 || backSlashIndex > closeSquareIndex) {
               return true;
             }
-            backSlashIndex = str.indexOf("\\", index);
+            backSlashIndex = str2.indexOf("\\", index);
             if (backSlashIndex === -1 || backSlashIndex > closeSquareIndex) {
               return true;
             }
           }
         }
-        if (closeCurlyIndex !== -1 && str[index] === "{" && str[index + 1] !== "}") {
-          closeCurlyIndex = str.indexOf("}", index);
+        if (closeCurlyIndex !== -1 && str2[index] === "{" && str2[index + 1] !== "}") {
+          closeCurlyIndex = str2.indexOf("}", index);
           if (closeCurlyIndex > index) {
-            backSlashIndex = str.indexOf("\\", index);
+            backSlashIndex = str2.indexOf("\\", index);
             if (backSlashIndex === -1 || backSlashIndex > closeCurlyIndex) {
               return true;
             }
           }
         }
-        if (closeParenIndex !== -1 && str[index] === "(" && str[index + 1] === "?" && /[:!=]/.test(str[index + 2]) && str[index + 3] !== ")") {
-          closeParenIndex = str.indexOf(")", index);
+        if (closeParenIndex !== -1 && str2[index] === "(" && str2[index + 1] === "?" && /[:!=]/.test(str2[index + 2]) && str2[index + 3] !== ")") {
+          closeParenIndex = str2.indexOf(")", index);
           if (closeParenIndex > index) {
-            backSlashIndex = str.indexOf("\\", index);
+            backSlashIndex = str2.indexOf("\\", index);
             if (backSlashIndex === -1 || backSlashIndex > closeParenIndex) {
               return true;
             }
           }
         }
-        if (pipeIndex !== -1 && str[index] === "(" && str[index + 1] !== "|") {
+        if (pipeIndex !== -1 && str2[index] === "(" && str2[index + 1] !== "|") {
           if (pipeIndex < index) {
-            pipeIndex = str.indexOf("|", index);
+            pipeIndex = str2.indexOf("|", index);
           }
-          if (pipeIndex !== -1 && str[pipeIndex + 1] !== ")") {
-            closeParenIndex = str.indexOf(")", pipeIndex);
+          if (pipeIndex !== -1 && str2[pipeIndex + 1] !== ")") {
+            closeParenIndex = str2.indexOf(")", pipeIndex);
             if (closeParenIndex > pipeIndex) {
-              backSlashIndex = str.indexOf("\\", pipeIndex);
+              backSlashIndex = str2.indexOf("\\", pipeIndex);
               if (backSlashIndex === -1 || backSlashIndex > closeParenIndex) {
                 return true;
               }
             }
           }
         }
-        if (str[index] === "\\") {
-          var open4 = str[index + 1];
+        if (str2[index] === "\\") {
+          var open4 = str2[index + 1];
           index += 2;
           var close = chars[open4];
           if (close) {
-            var n = str.indexOf(close, index);
+            var n = str2.indexOf(close, index);
             if (n !== -1) {
               index = n + 1;
             }
           }
-          if (str[index] === "!") {
+          if (str2[index] === "!") {
             return true;
           }
         } else {
@@ -277,26 +277,26 @@ var require_is_glob = __commonJS({
       }
       return false;
     };
-    var relaxedCheck = function(str) {
-      if (str[0] === "!") {
+    var relaxedCheck = function(str2) {
+      if (str2[0] === "!") {
         return true;
       }
       var index = 0;
-      while (index < str.length) {
-        if (/[*?{}()[\]]/.test(str[index])) {
+      while (index < str2.length) {
+        if (/[*?{}()[\]]/.test(str2[index])) {
           return true;
         }
-        if (str[index] === "\\") {
-          var open4 = str[index + 1];
+        if (str2[index] === "\\") {
+          var open4 = str2[index + 1];
           index += 2;
           var close = chars[open4];
           if (close) {
-            var n = str.indexOf(close, index);
+            var n = str2.indexOf(close, index);
             if (n !== -1) {
               index = n + 1;
             }
           }
-          if (str[index] === "!") {
+          if (str2[index] === "!") {
             return true;
           }
         } else {
@@ -305,18 +305,18 @@ var require_is_glob = __commonJS({
       }
       return false;
     };
-    module.exports = function isGlob(str, options) {
-      if (typeof str !== "string" || str === "") {
+    module.exports = function isGlob(str2, options) {
+      if (typeof str2 !== "string" || str2 === "") {
         return false;
       }
-      if (isExtglob(str)) {
+      if (isExtglob(str2)) {
         return true;
       }
       var check2 = strictCheck;
       if (options && options.strict === false) {
         check2 = relaxedCheck;
       }
-      return check2(str);
+      return check2(str2);
     };
   }
 });
@@ -334,19 +334,19 @@ var require_glob_parent = __commonJS({
     var enclosure = /[\{\[].*[\}\]]$/;
     var globby = /(^|[^\\])([\{\[]|\([^\)]+$)/;
     var escaped = /\\([\!\*\?\|\[\]\(\)\{\}])/g;
-    module.exports = function globParent(str, opts) {
+    module.exports = function globParent(str2, opts) {
       var options = Object.assign({ flipBackslashes: true }, opts);
-      if (options.flipBackslashes && isWin32 && str.indexOf(slash) < 0) {
-        str = str.replace(backslash, slash);
+      if (options.flipBackslashes && isWin32 && str2.indexOf(slash) < 0) {
+        str2 = str2.replace(backslash, slash);
       }
-      if (enclosure.test(str)) {
-        str += slash;
+      if (enclosure.test(str2)) {
+        str2 += slash;
       }
-      str += "a";
+      str2 += "a";
       do {
-        str = pathPosixDirname(str);
-      } while (isGlob(str) || globby.test(str));
-      return str.replace(escaped, "$1");
+        str2 = pathPosixDirname(str2);
+      } while (isGlob(str2) || globby.test(str2));
+      return str2.replace(escaped, "$1");
     };
   }
 });
@@ -356,12 +356,12 @@ var require_utils = __commonJS({
   "node_modules/braces/lib/utils.js"(exports) {
     "use strict";
     init_esm_shims();
-    exports.isInteger = (num) => {
-      if (typeof num === "number") {
-        return Number.isInteger(num);
+    exports.isInteger = (num4) => {
+      if (typeof num4 === "number") {
+        return Number.isInteger(num4);
       }
-      if (typeof num === "string" && num.trim() !== "") {
-        return Number.isInteger(Number(num));
+      if (typeof num4 === "string" && num4.trim() !== "") {
+        return Number.isInteger(Number(num4));
       }
       return false;
     };
@@ -471,12 +471,12 @@ var require_is_number = __commonJS({
   "node_modules/is-number/index.js"(exports, module) {
     "use strict";
     init_esm_shims();
-    module.exports = function(num) {
-      if (typeof num === "number") {
-        return num - num === 0;
+    module.exports = function(num4) {
+      if (typeof num4 === "number") {
+        return num4 - num4 === 0;
       }
-      if (typeof num === "string" && num.trim() !== "") {
-        return Number.isFinite ? Number.isFinite(+num) : isFinite(+num);
+      if (typeof num4 === "string" && num4.trim() !== "") {
+        return Number.isFinite ? Number.isFinite(+num4) : isFinite(+num4);
       }
       return false;
     };
@@ -600,7 +600,7 @@ var require_to_regex_range = __commonJS({
       }
       return { pattern, count: [count], digits };
     }
-    function splitToPatterns(min, max, tok, options) {
+    function splitToPatterns(min, max, tok2, options) {
       let ranges = splitToRanges(min, max);
       let tokens = [];
       let start = min;
@@ -609,7 +609,7 @@ var require_to_regex_range = __commonJS({
         let max2 = ranges[i];
         let obj = rangeToPattern(String(start), String(max2), options);
         let zeros = "";
-        if (!tok.isPadded && prev && prev.pattern === obj.pattern) {
+        if (!tok2.isPadded && prev && prev.pattern === obj.pattern) {
           if (prev.count.length > 1) {
             prev.count.pop();
           }
@@ -618,8 +618,8 @@ var require_to_regex_range = __commonJS({
           start = max2 + 1;
           continue;
         }
-        if (tok.isPadded) {
-          zeros = padZeros(max2, tok, options);
+        if (tok2.isPadded) {
+          zeros = padZeros(max2, tok2, options);
         }
         obj.string = zeros + obj.pattern + toQuantifier(obj.count);
         tokens.push(obj);
@@ -668,14 +668,14 @@ var require_to_regex_range = __commonJS({
     function toCharacterClass(a, b, options) {
       return `[${a}${b - a === 1 ? "" : "-"}${b}]`;
     }
-    function hasPadding(str) {
-      return /^-?(0+)\d/.test(str);
+    function hasPadding(str2) {
+      return /^-?(0+)\d/.test(str2);
     }
-    function padZeros(value, tok, options) {
-      if (!tok.isPadded) {
+    function padZeros(value, tok2, options) {
+      if (!tok2.isPadded) {
         return value;
       }
-      let diff = Math.abs(tok.maxLen - String(value).length);
+      let diff = Math.abs(tok2.maxLen - String(value).length);
       let relax = options.relaxZeros !== false;
       switch (diff) {
         case 0:
@@ -709,7 +709,7 @@ var require_fill_range = __commonJS({
     var isValidValue = (value) => {
       return typeof value === "number" || typeof value === "string" && value !== "";
     };
-    var isNumber = (num) => Number.isInteger(+num);
+    var isNumber = (num4) => Number.isInteger(+num4);
     var zeros = (input2) => {
       let value = `${input2}`;
       let index = -1;
@@ -819,7 +819,7 @@ var require_fill_range = __commonJS({
         return toRange(toMaxLen(start, maxLen), toMaxLen(end, maxLen), true, options);
       }
       let parts = { negatives: [], positives: [] };
-      let push = (num) => parts[num < 0 ? "negatives" : "positives"].push(Math.abs(num));
+      let push = (num4) => parts[num4 < 0 ? "negatives" : "positives"].push(Math.abs(num4));
       let range = [];
       let index = 0;
       while (descending ? a >= b : a <= b) {
@@ -1659,12 +1659,12 @@ var require_utils2 = __commonJS({
       REGEX_SPECIAL_CHARS_GLOBAL
     } = require_constants2();
     exports.isObject = (val) => val !== null && typeof val === "object" && !Array.isArray(val);
-    exports.hasRegexChars = (str) => REGEX_SPECIAL_CHARS.test(str);
-    exports.isRegexChar = (str) => str.length === 1 && exports.hasRegexChars(str);
-    exports.escapeRegex = (str) => str.replace(REGEX_SPECIAL_CHARS_GLOBAL, "\\$1");
-    exports.toPosixSlashes = (str) => str.replace(REGEX_BACKSLASH, "/");
-    exports.removeBackslashes = (str) => {
-      return str.replace(REGEX_REMOVE_BACKSLASH, (match) => {
+    exports.hasRegexChars = (str2) => REGEX_SPECIAL_CHARS.test(str2);
+    exports.isRegexChar = (str2) => str2.length === 1 && exports.hasRegexChars(str2);
+    exports.escapeRegex = (str2) => str2.replace(REGEX_SPECIAL_CHARS_GLOBAL, "\\$1");
+    exports.toPosixSlashes = (str2) => str2.replace(REGEX_BACKSLASH, "/");
+    exports.removeBackslashes = (str2) => {
+      return str2.replace(REGEX_REMOVE_BACKSLASH, (match) => {
         return match === "\\" ? "" : match;
       });
     };
@@ -1760,7 +1760,7 @@ var require_scan = __commonJS({
       const slashes = [];
       const tokens = [];
       const parts = [];
-      let str = input2;
+      let str2 = input2;
       let index = -1;
       let start = 0;
       let lastIndex = 0;
@@ -1779,10 +1779,10 @@ var require_scan = __commonJS({
       let code;
       let token = { value: "", depth: 0, isGlob: false };
       const eos = () => index >= length;
-      const peek = () => str.charCodeAt(index + 1);
+      const peek = () => str2.charCodeAt(index + 1);
       const advance = () => {
         prev = code;
-        return str.charCodeAt(++index);
+        return str2.charCodeAt(++index);
       };
       while (index < length) {
         code = advance();
@@ -1950,24 +1950,24 @@ var require_scan = __commonJS({
         isExtglob = false;
         isGlob = false;
       }
-      let base = str;
+      let base = str2;
       let prefix = "";
       let glob = "";
       if (start > 0) {
-        prefix = str.slice(0, start);
-        str = str.slice(start);
+        prefix = str2.slice(0, start);
+        str2 = str2.slice(start);
         lastIndex -= start;
       }
       if (base && isGlob === true && lastIndex > 0) {
-        base = str.slice(0, lastIndex);
-        glob = str.slice(lastIndex);
+        base = str2.slice(0, lastIndex);
+        glob = str2.slice(lastIndex);
       } else if (isGlob === true) {
         base = "";
-        glob = str;
+        glob = str2;
       } else {
-        base = str;
+        base = str2;
       }
-      if (base && base !== "" && base !== "/" && base !== str) {
+      if (base && base !== "" && base !== "/" && base !== str2) {
         if (isPathSeparator(base.charCodeAt(base.length - 1))) {
           base = base.slice(0, -1);
         }
@@ -2346,9 +2346,9 @@ var require_parse2 = __commonJS({
       const peek = state.peek = (n = 1) => input2[state.index + n];
       const advance = state.advance = () => input2[++state.index] || "";
       const remaining = () => input2.slice(state.index + 1);
-      const consume = (value2 = "", num = 0) => {
+      const consume = (value2 = "", num4 = 0) => {
         state.consumed += value2;
-        state.index += num;
+        state.index += num4;
       };
       const append = (token) => {
         state.output += token.output != null ? token.output : token.value;
@@ -2376,11 +2376,11 @@ var require_parse2 = __commonJS({
         state[type]--;
         stack.pop();
       };
-      const push = (tok) => {
+      const push = (tok2) => {
         if (prev.type === "globstar") {
-          const isBrace = state.braces > 0 && (tok.type === "comma" || tok.type === "brace");
-          const isExtglob = tok.extglob === true || extglobs.length && (tok.type === "pipe" || tok.type === "paren");
-          if (tok.type !== "slash" && tok.type !== "paren" && !isBrace && !isExtglob) {
+          const isBrace = state.braces > 0 && (tok2.type === "comma" || tok2.type === "brace");
+          const isExtglob = tok2.extglob === true || extglobs.length && (tok2.type === "pipe" || tok2.type === "paren");
+          if (tok2.type !== "slash" && tok2.type !== "paren" && !isBrace && !isExtglob) {
             state.output = state.output.slice(0, -prev.output.length);
             prev.type = "star";
             prev.value = "*";
@@ -2388,18 +2388,18 @@ var require_parse2 = __commonJS({
             state.output += prev.output;
           }
         }
-        if (extglobs.length && tok.type !== "paren") {
-          extglobs[extglobs.length - 1].inner += tok.value;
+        if (extglobs.length && tok2.type !== "paren") {
+          extglobs[extglobs.length - 1].inner += tok2.value;
         }
-        if (tok.value || tok.output) append(tok);
-        if (prev && prev.type === "text" && tok.type === "text") {
-          prev.value += tok.value;
-          prev.output = (prev.output || "") + tok.value;
+        if (tok2.value || tok2.output) append(tok2);
+        if (prev && prev.type === "text" && tok2.type === "text") {
+          prev.value += tok2.value;
+          prev.output = (prev.output || "") + tok2.value;
           return;
         }
-        tok.prev = prev;
-        tokens.push(tok);
-        prev = tok;
+        tok2.prev = prev;
+        tokens.push(tok2);
+        prev = tok2;
       };
       const extglobOpen = (type, value2) => {
         const token = { ...EXTGLOB_CHARS[value2], conditions: 1, inner: "" };
@@ -3003,8 +3003,8 @@ var require_parse2 = __commonJS({
         if (opts2.noglobstar === true) return star;
         return `(${capture}(?:(?!${START_ANCHOR}${opts2.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
       };
-      const create = (str) => {
-        switch (str) {
+      const create = (str2) => {
+        switch (str2) {
           case "*":
             return `${nodot}${ONE_CHAR}${star}`;
           case ".*":
@@ -3022,7 +3022,7 @@ var require_parse2 = __commonJS({
           case "**/.*":
             return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${DOT_LITERAL}${ONE_CHAR}${star}`;
           default: {
-            const match = /^(.*?)\.(\w+)$/.exec(str);
+            const match = /^(.*?)\.(\w+)$/.exec(str2);
             if (!match) return;
             const source2 = create(match[1]);
             if (!source2) return;
@@ -3055,9 +3055,9 @@ var require_picomatch = __commonJS({
     var picomatch = (glob, options, returnState = false) => {
       if (Array.isArray(glob)) {
         const fns = glob.map((input2) => picomatch(input2, options, returnState));
-        const arrayMatcher = (str) => {
+        const arrayMatcher = (str2) => {
           for (const isMatch of fns) {
-            const state2 = isMatch(str);
+            const state2 = isMatch(str2);
             if (state2) return state2;
           }
           return false;
@@ -3133,7 +3133,7 @@ var require_picomatch = __commonJS({
       const regex = glob instanceof RegExp ? glob : picomatch.makeRe(glob, options);
       return regex.test(path2.basename(input2));
     };
-    picomatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str);
+    picomatch.isMatch = (str2, patterns, options) => picomatch(patterns, options)(str2);
     picomatch.parse = (pattern, options) => {
       if (Array.isArray(pattern)) return pattern.map((p) => picomatch.parse(p, options));
       return parse4(pattern, { ...options, fastpaths: false });
@@ -3249,7 +3249,7 @@ var require_micromatch = __commonJS({
     };
     micromatch.match = micromatch;
     micromatch.matcher = (pattern, options) => picomatch(pattern, options);
-    micromatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str);
+    micromatch.isMatch = (str2, patterns, options) => picomatch(patterns, options)(str2);
     micromatch.any = micromatch.isMatch;
     micromatch.not = (list, patterns, options = {}) => {
       patterns = [].concat(patterns).map(String);
@@ -3267,22 +3267,22 @@ var require_micromatch = __commonJS({
       }
       return [...result];
     };
-    micromatch.contains = (str, pattern, options) => {
-      if (typeof str !== "string") {
-        throw new TypeError(`Expected a string: "${util.inspect(str)}"`);
+    micromatch.contains = (str2, pattern, options) => {
+      if (typeof str2 !== "string") {
+        throw new TypeError(`Expected a string: "${util.inspect(str2)}"`);
       }
       if (Array.isArray(pattern)) {
-        return pattern.some((p) => micromatch.contains(str, p, options));
+        return pattern.some((p) => micromatch.contains(str2, p, options));
       }
       if (typeof pattern === "string") {
-        if (isEmptyString(str) || isEmptyString(pattern)) {
+        if (isEmptyString(str2) || isEmptyString(pattern)) {
           return false;
         }
-        if (str.includes(pattern) || str.startsWith("./") && str.slice(2).includes(pattern)) {
+        if (str2.includes(pattern) || str2.startsWith("./") && str2.slice(2).includes(pattern)) {
           return true;
         }
       }
-      return micromatch.isMatch(str, pattern, { ...options, contains: true });
+      return micromatch.isMatch(str2, pattern, { ...options, contains: true });
     };
     micromatch.matchKeys = (obj, patterns, options) => {
       if (!utils.isObject(obj)) {
@@ -3313,11 +3313,11 @@ var require_micromatch = __commonJS({
       }
       return true;
     };
-    micromatch.all = (str, patterns, options) => {
-      if (typeof str !== "string") {
-        throw new TypeError(`Expected a string: "${util.inspect(str)}"`);
+    micromatch.all = (str2, patterns, options) => {
+      if (typeof str2 !== "string") {
+        throw new TypeError(`Expected a string: "${util.inspect(str2)}"`);
       }
-      return [].concat(patterns).every((p) => picomatch(p, options)(str));
+      return [].concat(patterns).every((p) => picomatch(p, options)(str2));
     };
     micromatch.capture = (glob, input2, options) => {
       let posix = utils.isWindows(options);
@@ -3332,8 +3332,8 @@ var require_micromatch = __commonJS({
     micromatch.parse = (patterns, options) => {
       let res = [];
       for (let pattern of [].concat(patterns || [])) {
-        for (let str of braces(String(pattern), options)) {
-          res.push(picomatch.parse(str, options));
+        for (let str2 of braces(String(pattern), options)) {
+          res.push(picomatch.parse(str2, options));
         }
       }
       return res;
@@ -3456,8 +3456,8 @@ var require_pattern = __commonJS({
     }
     exports.endsWithSlashGlobStar = endsWithSlashGlobStar;
     function isAffectDepthOfReadingPattern(pattern) {
-      const basename = path2.basename(pattern);
-      return endsWithSlashGlobStar(pattern) || isStaticPattern(basename);
+      const basename2 = path2.basename(pattern);
+      return endsWithSlashGlobStar(pattern) || isStaticPattern(basename2);
     }
     exports.isAffectDepthOfReadingPattern = isAffectDepthOfReadingPattern;
     function expandPatternsWithBraceExpansion(patterns) {
@@ -3941,11 +3941,11 @@ var require_out = __commonJS({
       async.read(path2, getSettings(optionsOrSettingsOrCallback), callback);
     }
     exports.stat = stat;
-    function statSync6(path2, optionsOrSettings) {
+    function statSync7(path2, optionsOrSettings) {
       const settings = getSettings(optionsOrSettings);
       return sync.read(path2, settings);
     }
-    exports.statSync = statSync6;
+    exports.statSync = statSync7;
     function getSettings(settingsOrOptions = {}) {
       if (settingsOrOptions instanceof settings_1.default) {
         return settingsOrOptions;
@@ -4626,41 +4626,41 @@ var require_queue = __commonJS({
       queue.drained = drained;
       return queue;
       function push(value) {
-        var p = new Promise(function(resolve4, reject) {
+        var p = new Promise(function(resolve5, reject) {
           pushCb(value, function(err, result) {
             if (err) {
               reject(err);
               return;
             }
-            resolve4(result);
+            resolve5(result);
           });
         });
         p.catch(noop);
         return p;
       }
       function unshift(value) {
-        var p = new Promise(function(resolve4, reject) {
+        var p = new Promise(function(resolve5, reject) {
           unshiftCb(value, function(err, result) {
             if (err) {
               reject(err);
               return;
             }
-            resolve4(result);
+            resolve5(result);
           });
         });
         p.catch(noop);
         return p;
       }
       function drained() {
-        var p = new Promise(function(resolve4) {
+        var p = new Promise(function(resolve5) {
           process.nextTick(function() {
             if (queue.idle()) {
-              resolve4();
+              resolve5();
             } else {
               var previousDrain = queue.drain;
               queue.drain = function() {
                 if (typeof previousDrain === "function") previousDrain();
-                resolve4();
+                resolve5();
                 queue.drain = previousDrain;
               };
             }
@@ -5157,9 +5157,9 @@ var require_stream3 = __commonJS({
         });
       }
       _getStat(filepath) {
-        return new Promise((resolve4, reject) => {
+        return new Promise((resolve5, reject) => {
           this._stat(filepath, this._fsStatSettings, (error62, stats) => {
-            return error62 === null ? resolve4(stats) : reject(error62);
+            return error62 === null ? resolve5(stats) : reject(error62);
           });
         });
       }
@@ -5184,10 +5184,10 @@ var require_async5 = __commonJS({
         this._readerStream = new stream_1.default(this._settings);
       }
       dynamic(root, options) {
-        return new Promise((resolve4, reject) => {
+        return new Promise((resolve5, reject) => {
           this._walkAsync(root, options, (error62, entries) => {
             if (error62 === null) {
-              resolve4(entries);
+              resolve5(entries);
             } else {
               reject(error62);
             }
@@ -5197,10 +5197,10 @@ var require_async5 = __commonJS({
       async static(patterns, options) {
         const entries = [];
         const stream = this._readerStream.static(patterns, options);
-        return new Promise((resolve4, reject) => {
+        return new Promise((resolve5, reject) => {
           stream.once("error", reject);
           stream.on("data", (entry) => entries.push(entry));
-          stream.once("end", () => resolve4(entries));
+          stream.once("end", () => resolve5(entries));
         });
       }
     };
@@ -5919,7 +5919,9 @@ var CATEGORIES = {
   tool_call: 4,
   session_start: 4,
   /** A proactive recall decision (fired or quiet) and what it showed; never in the guide. */
-  recall: 4
+  recall: 4,
+  /** A routing decision (allow / annotate / deny) for one native call; never in the guide. */
+  routing: 4
 };
 var GUIDE_ORDER = [
   { title: "Last Request", categories: ["user_prompt"] },
@@ -5968,8 +5970,8 @@ function withPriority(sessionId, drafts) {
   return drafts.map((d) => ({ ...d, sessionId, priority: CATEGORIES[d.category] }));
 }
 var clip = (s, n) => {
-  const str = typeof s === "string" ? s : JSON.stringify(s ?? "");
-  return str.length > n ? `${str.slice(0, n - 1)}\u2026` : str;
+  const str2 = typeof s === "string" ? s : JSON.stringify(s ?? "");
+  return str2.length > n ? `${str2.slice(0, n - 1)}\u2026` : str2;
 };
 var DECISION = /\b(let'?s go with|we'?ll use|decided|decision:|go with|use (?:the )?\w+ instead|stick with|switch(?:ing)? to|chose|prefer(?:red)?)\b/i;
 var CONSTRAINT = /\b(must(?: not)?|never|always|only|do not|don'?t|should not|required?|hard requirement|no\s+\w+ allowed)\b/i;
@@ -6964,14 +6966,14 @@ function promiseAllObject(promisesObj) {
 }
 function randomString(length = 10) {
   const chars = "abcdefghijklmnopqrstuvwxyz";
-  let str = "";
+  let str2 = "";
   for (let i = 0; i < length; i++) {
-    str += chars[Math.floor(Math.random() * chars.length)];
+    str2 += chars[Math.floor(Math.random() * chars.length)];
   }
-  return str;
+  return str2;
 }
-function esc(str) {
-  return JSON.stringify(str);
+function esc(str2) {
+  return JSON.stringify(str2);
 }
 function slugify(input2) {
   return input2.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/[\s_-]+/g, "-").replace(/^-+|-+$/g, "");
@@ -7085,8 +7087,8 @@ var primitiveTypes = /* @__PURE__ */ new Set([
   "symbol",
   "undefined"
 ]);
-function escapeRegex(str) {
-  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function escapeRegex(str2) {
+  return str2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function clone(inst, def, params) {
   const cl = new inst._zod.constr(def ?? inst._zod.def);
@@ -7352,13 +7354,13 @@ function getSizableOrigin(input2) {
   return "unknown";
 }
 var highSurrogate = /[\uD800-\uDBFF]/;
-function codePointLength(str) {
-  const units = str.length;
-  if (!highSurrogate.test(str))
+function codePointLength(str2) {
+  const units = str2.length;
+  if (!highSurrogate.test(str2))
     return units;
   let count = units;
   for (let i = 0; i < units - 1; i++) {
-    if ((str.charCodeAt(i) & 64512) === 55296 && (str.charCodeAt(i + 1) & 64512) === 56320) {
+    if ((str2.charCodeAt(i) & 64512) === 55296 && (str2.charCodeAt(i + 1) & 64512) === 56320) {
       count--;
       i++;
     }
@@ -11210,7 +11212,7 @@ var recursive = /* @__PURE__ */ new WeakMap();
 var NONE = 0;
 var ASSUMED = 1;
 var PROVEN = 2;
-function isRecursive(inst, stack, resolve4) {
+function isRecursive(inst, stack, resolve5) {
   const cached3 = recursive.get(inst);
   if (cached3 !== void 0)
     return cached3 ? PROVEN : NONE;
@@ -11220,7 +11222,7 @@ function isRecursive(inst, stack, resolve4) {
   let result = NONE;
   const check2 = (child) => {
     if (result !== PROVEN && child?._zod) {
-      const answer = isRecursive(child, stack, resolve4);
+      const answer = isRecursive(child, stack, resolve5);
       if (answer > result)
         result = answer;
     }
@@ -11231,7 +11233,7 @@ function isRecursive(inst, stack, resolve4) {
       const desc = Object.getOwnPropertyDescriptor(sh, key);
       if (spread && !desc.enumerable)
         continue;
-      const child = desc.get ? ASSUMED : desc.value?._zod ? isRecursive(desc.value, stack, resolve4) : NONE;
+      const child = desc.get ? ASSUMED : desc.value?._zod ? isRecursive(desc.value, stack, resolve5) : NONE;
       if (child > answer)
         answer = child;
     }
@@ -11295,7 +11297,7 @@ function isRecursive(inst, stack, resolve4) {
       break;
     // `$ZodLazy` caches its inner on the def, so a resolved edge is followed exactly
     case "lazy": {
-      const inner = def._cachedInner ?? (resolve4 ? inst._zod.innerType : void 0);
+      const inner = def._cachedInner ?? (resolve5 ? inst._zod.innerType : void 0);
       merge2(inner ? isRecursive(inner, stack, false) : ASSUMED);
       break;
     }
@@ -26145,6 +26147,33 @@ var ConfigSchema = external_exports.object({
         }).optional()
       })
     ).default([])
+  }).prefault({}),
+  usage: external_exports.object({
+    /** Ingest Claude Code transcripts (tokens, cache, cost per model call) and record statusline snapshots. */
+    enabled: external_exports.boolean().default(true),
+    /** Soft budgets; crossing one adds a one-line warning to the next prompt (never blocks). */
+    budgets: external_exports.object({
+      sessionUsd: external_exports.number().positive().optional(),
+      dailyUsd: external_exports.number().positive().optional(),
+      /** A single API call above this is flagged as an expensive turn. */
+      turnUsd: external_exports.number().positive().optional()
+    }).prefault({}),
+    /**
+     * Price overrides per model, USD per million tokens, matched by substring of the model id
+     * (first match wins). Missing fields fall back to the bundled table.
+     */
+    pricing: external_exports.record(
+      external_exports.string(),
+      external_exports.object({
+        input: external_exports.number().nonnegative().optional(),
+        output: external_exports.number().nonnegative().optional(),
+        cacheWrite5m: external_exports.number().nonnegative().optional(),
+        cacheWrite1h: external_exports.number().nonnegative().optional(),
+        cacheRead: external_exports.number().nonnegative().optional()
+      })
+    ).default({}),
+    /** Show cost, context and plan usage segments in `eminiar statusline`. */
+    statusline: external_exports.boolean().default(true)
   }).prefault({})
 });
 function readJson(file3) {
@@ -27855,6 +27884,107 @@ CREATE TABLE IF NOT EXISTS index_runs (
   head_sha TEXT,
   detail TEXT
 );
+`
+  },
+  {
+    // Usage insights: api_calls mirrors one API request per Claude Code transcript entry
+    // (deduped on request_id + message_id; cost cached at ingest), tool_uses pairs each
+    // tool_use block with its tool_result size, context_events records compactions,
+    // transcript_files keeps the byte offset so ingest only reads new bytes, and
+    // statusline_snapshots stores what `eminiar statusline` saw. Column names = row fields.
+    version: 5,
+    sql: `
+CREATE TABLE IF NOT EXISTS api_calls (
+  request_id TEXT NOT NULL,
+  message_id TEXT NOT NULL,
+  session_id TEXT NOT NULL,
+  agent_id TEXT,
+  sidechain INTEGER NOT NULL DEFAULT 0,
+  ts INTEGER NOT NULL,
+  model TEXT NOT NULL,
+  input_tokens INTEGER NOT NULL DEFAULT 0,
+  output_tokens INTEGER NOT NULL DEFAULT 0,
+  cache_create_5m INTEGER NOT NULL DEFAULT 0,
+  cache_create_1h INTEGER NOT NULL DEFAULT 0,
+  cache_read INTEGER NOT NULL DEFAULT 0,
+  thinking_tokens INTEGER NOT NULL DEFAULT 0,
+  web_searches INTEGER NOT NULL DEFAULT 0,
+  web_fetches INTEGER NOT NULL DEFAULT 0,
+  service_tier TEXT,
+  speed TEXT,
+  stop_reason TEXT,
+  prompt_id TEXT,
+  git_branch TEXT,
+  cwd TEXT,
+  effort TEXT,
+  version TEXT,
+  entrypoint TEXT,
+  cost_usd REAL,
+  priced INTEGER NOT NULL DEFAULT 0,
+  PRIMARY KEY (request_id, message_id)
+);
+CREATE INDEX IF NOT EXISTS api_calls_session_ts ON api_calls(session_id, ts);
+CREATE INDEX IF NOT EXISTS api_calls_ts ON api_calls(ts);
+
+CREATE TABLE IF NOT EXISTS tool_uses (
+  tool_use_id TEXT PRIMARY KEY,
+  session_id TEXT NOT NULL,
+  agent_id TEXT,
+  ts INTEGER NOT NULL,
+  tool TEXT NOT NULL,
+  input_chars INTEGER NOT NULL DEFAULT 0,
+  result_chars INTEGER,
+  is_error INTEGER NOT NULL DEFAULT 0,
+  request_id TEXT
+);
+CREATE INDEX IF NOT EXISTS tool_uses_session_ts ON tool_uses(session_id, ts);
+CREATE INDEX IF NOT EXISTS tool_uses_ts ON tool_uses(ts);
+
+CREATE TABLE IF NOT EXISTS context_events (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  session_id TEXT NOT NULL,
+  ts INTEGER NOT NULL,
+  kind TEXT NOT NULL,
+  trigger TEXT,
+  pre_tokens INTEGER,
+  post_tokens INTEGER
+);
+CREATE INDEX IF NOT EXISTS context_events_session_ts ON context_events(session_id, ts);
+CREATE INDEX IF NOT EXISTS context_events_ts ON context_events(ts);
+
+CREATE TABLE IF NOT EXISTS transcript_files (
+  path TEXT PRIMARY KEY,
+  session_id TEXT,
+  offset INTEGER NOT NULL DEFAULT 0,
+  size INTEGER NOT NULL DEFAULT 0,
+  mtime INTEGER NOT NULL DEFAULT 0,
+  head_hash TEXT,
+  ingested_at INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS statusline_snapshots (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  session_id TEXT NOT NULL,
+  ts INTEGER NOT NULL,
+  model_id TEXT,
+  cost_usd REAL,
+  api_ms INTEGER,
+  duration_ms INTEGER,
+  ctx_input_tokens INTEGER,
+  ctx_output_tokens INTEGER,
+  ctx_size INTEGER,
+  ctx_used_pct REAL,
+  cache_warm INTEGER,
+  cache_ttl TEXT,
+  five_hour_pct REAL,
+  five_hour_resets_at INTEGER,
+  seven_day_pct REAL,
+  seven_day_resets_at INTEGER,
+  lines_added INTEGER,
+  lines_removed INTEGER
+);
+CREATE INDEX IF NOT EXISTS statusline_snapshots_session_ts ON statusline_snapshots(session_id, ts);
+CREATE INDEX IF NOT EXISTS statusline_snapshots_ts ON statusline_snapshots(ts);
 `
   }
 ];
@@ -27894,6 +28024,27 @@ function filterSql(f) {
   }
   return { where: clauses.length ? ` AND ${clauses.join(" AND ")}` : "", params };
 }
+function usageWhere(f, opts = {}) {
+  const clauses = ["1=1"];
+  const params = [];
+  if (f.sessionId) {
+    clauses.push("session_id = ?");
+    params.push(f.sessionId);
+  }
+  if (f.since !== void 0) {
+    clauses.push("ts >= ?");
+    params.push(f.since);
+  }
+  if (f.until !== void 0) {
+    clauses.push("ts < ?");
+    params.push(f.until);
+  }
+  if (f.sidechain !== void 0 && opts.sidechain !== null) {
+    const expr = opts.sidechain ?? "sidechain = 1";
+    clauses.push(f.sidechain ? expr : `NOT (${expr})`);
+  }
+  return { where: clauses.join(" AND "), params };
+}
 var SqliteAdapter = class _SqliteAdapter {
   constructor(path2, opts = {}) {
     this.path = path2;
@@ -28769,6 +28920,233 @@ var SqliteAdapter = class _SqliteAdapter {
   memoryCount() {
     return this.db.prepare("SELECT COUNT(*) n FROM memories").get().n;
   }
+  // --- usage: model calls, tool results, context events, statusline ------------
+  apiCallsUpsert(rows) {
+    if (!rows.length) return 0;
+    const ins = this.prep(
+      `INSERT INTO api_calls (request_id, message_id, session_id, agent_id, sidechain, ts, model,
+         input_tokens, output_tokens, cache_create_5m, cache_create_1h, cache_read, thinking_tokens,
+         web_searches, web_fetches, service_tier, speed, stop_reason, prompt_id, git_branch, cwd, effort,
+         version, entrypoint, cost_usd, priced)
+       VALUES (@request_id, @message_id, @session_id, @agent_id, @sidechain, @ts, @model,
+         @input_tokens, @output_tokens, @cache_create_5m, @cache_create_1h, @cache_read, @thinking_tokens,
+         @web_searches, @web_fetches, @service_tier, @speed, @stop_reason, @prompt_id, @git_branch, @cwd, @effort,
+         @version, @entrypoint, @cost_usd, @priced)
+       ON CONFLICT(request_id, message_id) DO UPDATE SET
+         cost_usd = CASE WHEN excluded.output_tokens >= api_calls.output_tokens THEN excluded.cost_usd ELSE api_calls.cost_usd END,
+         priced = CASE WHEN excluded.output_tokens >= api_calls.output_tokens THEN excluded.priced ELSE api_calls.priced END,
+         input_tokens = MAX(api_calls.input_tokens, excluded.input_tokens),
+         output_tokens = MAX(api_calls.output_tokens, excluded.output_tokens),
+         cache_create_5m = MAX(api_calls.cache_create_5m, excluded.cache_create_5m),
+         cache_create_1h = MAX(api_calls.cache_create_1h, excluded.cache_create_1h),
+         cache_read = MAX(api_calls.cache_read, excluded.cache_read),
+         thinking_tokens = MAX(api_calls.thinking_tokens, excluded.thinking_tokens),
+         web_searches = MAX(api_calls.web_searches, excluded.web_searches),
+         web_fetches = MAX(api_calls.web_fetches, excluded.web_fetches),
+         stop_reason = COALESCE(excluded.stop_reason, api_calls.stop_reason),
+         service_tier = COALESCE(excluded.service_tier, api_calls.service_tier),
+         speed = COALESCE(excluded.speed, api_calls.speed),
+         prompt_id = COALESCE(api_calls.prompt_id, excluded.prompt_id),
+         effort = COALESCE(api_calls.effort, excluded.effort)`
+    );
+    const count = this.prep("SELECT COUNT(*) AS n FROM api_calls");
+    return this.transaction(() => {
+      const before = count.get().n;
+      for (const r of rows) {
+        ins.run({
+          request_id: r.request_id,
+          message_id: r.message_id,
+          session_id: r.session_id,
+          agent_id: r.agent_id ?? null,
+          sidechain: r.sidechain ? 1 : 0,
+          ts: r.ts,
+          model: r.model,
+          input_tokens: r.input_tokens,
+          output_tokens: r.output_tokens,
+          cache_create_5m: r.cache_create_5m,
+          cache_create_1h: r.cache_create_1h,
+          cache_read: r.cache_read,
+          thinking_tokens: r.thinking_tokens,
+          web_searches: r.web_searches,
+          web_fetches: r.web_fetches,
+          service_tier: r.service_tier ?? null,
+          speed: r.speed ?? null,
+          stop_reason: r.stop_reason ?? null,
+          prompt_id: r.prompt_id ?? null,
+          git_branch: r.git_branch ?? null,
+          cwd: r.cwd ?? null,
+          effort: r.effort ?? null,
+          version: r.version ?? null,
+          entrypoint: r.entrypoint ?? null,
+          cost_usd: r.cost_usd ?? null,
+          priced: r.priced ?? 0
+        });
+      }
+      return count.get().n - before;
+    });
+  }
+  apiCalls(filter = {}) {
+    const { where, params } = usageWhere(filter);
+    params.push(filter.limit ?? 1e5);
+    return this.prep(
+      `SELECT * FROM api_calls WHERE ${where} ORDER BY ts ASC, rowid ASC LIMIT ?`
+    ).all(...params);
+  }
+  apiCallsLatestTs() {
+    const row = this.prep("SELECT MAX(ts) AS ts FROM api_calls").get();
+    return row?.ts ?? void 0;
+  }
+  toolUsesUpsert(rows) {
+    if (!rows.length) return 0;
+    const ins = this.prep(
+      `INSERT INTO tool_uses (tool_use_id, session_id, agent_id, ts, tool, input_chars, result_chars, is_error, request_id)
+       VALUES (@tool_use_id, @session_id, @agent_id, @ts, @tool, @input_chars, @result_chars, @is_error, @request_id)
+       ON CONFLICT(tool_use_id) DO UPDATE SET
+         tool = CASE WHEN tool_uses.tool = '' THEN excluded.tool ELSE tool_uses.tool END,
+         input_chars = MAX(tool_uses.input_chars, excluded.input_chars),
+         result_chars = COALESCE(excluded.result_chars, tool_uses.result_chars),
+         is_error = MAX(tool_uses.is_error, excluded.is_error),
+         request_id = COALESCE(tool_uses.request_id, excluded.request_id),
+         agent_id = COALESCE(tool_uses.agent_id, excluded.agent_id),
+         ts = MIN(tool_uses.ts, excluded.ts)`
+    );
+    const count = this.prep("SELECT COUNT(*) AS n FROM tool_uses");
+    return this.transaction(() => {
+      const before = count.get().n;
+      for (const r of rows) {
+        ins.run({
+          tool_use_id: r.tool_use_id,
+          session_id: r.session_id,
+          agent_id: r.agent_id ?? null,
+          ts: r.ts,
+          tool: r.tool,
+          input_chars: r.input_chars,
+          result_chars: r.result_chars ?? null,
+          is_error: r.is_error ? 1 : 0,
+          request_id: r.request_id ?? null
+        });
+      }
+      return count.get().n - before;
+    });
+  }
+  toolUses(filter = {}) {
+    const { where, params } = usageWhere(filter, { sidechain: "agent_id IS NOT NULL" });
+    params.push(filter.limit ?? 1e5);
+    return this.prep(
+      `SELECT * FROM tool_uses WHERE ${where} ORDER BY ts ASC, rowid ASC LIMIT ?`
+    ).all(...params);
+  }
+  contextEventInsert(e) {
+    const info = this.prep(
+      `INSERT INTO context_events (session_id, ts, kind, trigger, pre_tokens, post_tokens)
+       VALUES (?, ?, ?, ?, ?, ?)`
+    ).run(
+      e.session_id,
+      e.ts,
+      e.kind,
+      e.trigger ?? null,
+      e.pre_tokens ?? null,
+      e.post_tokens ?? null
+    );
+    return Number(info.lastInsertRowid);
+  }
+  contextEvents(filter = {}) {
+    const { where, params } = usageWhere(filter, { sidechain: null });
+    params.push(filter.limit ?? 1e5);
+    return this.prep(
+      `SELECT * FROM context_events WHERE ${where} ORDER BY ts ASC, id ASC LIMIT ?`
+    ).all(...params);
+  }
+  transcriptFileGet(path2) {
+    return this.prep("SELECT * FROM transcript_files WHERE path = ?").get(path2);
+  }
+  transcriptFileSet(row) {
+    this.prep(
+      `INSERT INTO transcript_files (path, session_id, offset, size, mtime, head_hash, ingested_at)
+       VALUES (@path, @session_id, @offset, @size, @mtime, @head_hash, @ingested_at)
+       ON CONFLICT(path) DO UPDATE SET
+         session_id = COALESCE(excluded.session_id, transcript_files.session_id),
+         offset = excluded.offset, size = excluded.size, mtime = excluded.mtime,
+         head_hash = excluded.head_hash, ingested_at = excluded.ingested_at`
+    ).run({
+      path: row.path,
+      session_id: row.session_id ?? null,
+      offset: row.offset,
+      size: row.size,
+      mtime: row.mtime,
+      head_hash: row.head_hash ?? null,
+      ingested_at: row.ingested_at
+    });
+  }
+  transcriptFiles() {
+    return this.prep("SELECT * FROM transcript_files ORDER BY path").all();
+  }
+  statuslineSnapshotInsert(s) {
+    const info = this.prep(
+      `INSERT INTO statusline_snapshots (session_id, ts, model_id, cost_usd, api_ms, duration_ms,
+         ctx_input_tokens, ctx_output_tokens, ctx_size, ctx_used_pct, cache_warm, cache_ttl,
+         five_hour_pct, five_hour_resets_at, seven_day_pct, seven_day_resets_at, lines_added, lines_removed)
+       VALUES (@session_id, @ts, @model_id, @cost_usd, @api_ms, @duration_ms,
+         @ctx_input_tokens, @ctx_output_tokens, @ctx_size, @ctx_used_pct, @cache_warm, @cache_ttl,
+         @five_hour_pct, @five_hour_resets_at, @seven_day_pct, @seven_day_resets_at, @lines_added, @lines_removed)`
+    ).run({
+      session_id: s.session_id,
+      ts: s.ts,
+      model_id: s.model_id ?? null,
+      cost_usd: s.cost_usd ?? null,
+      api_ms: s.api_ms ?? null,
+      duration_ms: s.duration_ms ?? null,
+      ctx_input_tokens: s.ctx_input_tokens ?? null,
+      ctx_output_tokens: s.ctx_output_tokens ?? null,
+      ctx_size: s.ctx_size ?? null,
+      ctx_used_pct: s.ctx_used_pct ?? null,
+      cache_warm: s.cache_warm ?? null,
+      cache_ttl: s.cache_ttl ?? null,
+      five_hour_pct: s.five_hour_pct ?? null,
+      five_hour_resets_at: s.five_hour_resets_at ?? null,
+      seven_day_pct: s.seven_day_pct ?? null,
+      seven_day_resets_at: s.seven_day_resets_at ?? null,
+      lines_added: s.lines_added ?? null,
+      lines_removed: s.lines_removed ?? null
+    });
+    return Number(info.lastInsertRowid);
+  }
+  statuslineSnapshots(filter = {}) {
+    const { where, params } = usageWhere(filter, { sidechain: null });
+    params.push(filter.limit ?? 1e5);
+    return this.prep(
+      `SELECT * FROM statusline_snapshots WHERE ${where} ORDER BY ts ASC, id ASC LIMIT ?`
+    ).all(...params);
+  }
+  statuslineLatest(sessionId) {
+    if (sessionId) {
+      return this.prep(
+        "SELECT * FROM statusline_snapshots WHERE session_id = ? ORDER BY ts DESC, id DESC LIMIT 1"
+      ).get(sessionId);
+    }
+    return this.prep(
+      "SELECT * FROM statusline_snapshots ORDER BY ts DESC, id DESC LIMIT 1"
+    ).get();
+  }
+  statuslineSnapshotsPrune(opts) {
+    const keep = Math.max(0, Math.floor(opts.keepPerSession));
+    return this.transaction(() => {
+      let n = this.prep("DELETE FROM statusline_snapshots WHERE ts < ?").run(
+        opts.olderThan
+      ).changes;
+      n += this.prep(
+        `DELETE FROM statusline_snapshots WHERE id IN (
+           SELECT s.id FROM statusline_snapshots s
+           WHERE s.id NOT IN (
+             SELECT k.id FROM statusline_snapshots k
+             WHERE k.session_id = s.session_id
+             ORDER BY k.ts DESC, k.id DESC LIMIT ?
+           )
+         )`
+      ).run(keep).changes;
+      return n;
+    });
+  }
   // --- misc --------------------------------------------------------------
   metaGet(key) {
     const row = this.db.prepare("SELECT value FROM meta WHERE key = ?").get(key);
@@ -28799,6 +29177,11 @@ var SqliteAdapter = class _SqliteAdapter {
           "DELETE FROM graph_edges; DELETE FROM graph_nodes; DELETE FROM graph_metrics;"
         );
       }
+      if (scope === "usage" || scope === "all") {
+        this.db.exec(
+          "DELETE FROM api_calls; DELETE FROM tool_uses; DELETE FROM context_events; DELETE FROM transcript_files; DELETE FROM statusline_snapshots;"
+        );
+      }
       if (scope === "memories" || scope === "all") {
         this.db.exec("DELETE FROM memories;");
         if (scope === "memories") {
@@ -28834,6 +29217,1544 @@ function getStorage(ctx, opts = {}) {
   return adapter;
 }
 
+// src/usage/brief.ts
+init_esm_shims();
+
+// src/usage/aggregate.ts
+init_esm_shims();
+
+// src/usage/blocks.ts
+init_esm_shims();
+
+// src/usage/pricing.ts
+init_esm_shims();
+var WEB_SEARCH_PER_1K = 10;
+function price(input2, output2, cacheRead, extra = {}) {
+  return {
+    input: input2,
+    output: output2,
+    cacheWrite5m: input2 * 1.25,
+    cacheWrite1h: input2 * 2,
+    cacheRead,
+    webSearch: WEB_SEARCH_PER_1K,
+    ...extra
+  };
+}
+var FABLE_5_1 = price(10, 50, 0.25);
+var FABLE_5 = price(10, 50, 1);
+var OPUS_5_5 = price(4, 20, 0.2);
+var OPUS_5 = price(5, 25, 0.5);
+var OPUS_4_LATE = price(5, 25, 0.5);
+var OPUS_4_EARLY = price(15, 75, 1.5);
+var SONNET_5_5 = price(2, 10, 0.1);
+var SONNET_5 = price(2, 10, 0.2);
+var SONNET_4 = price(3, 15, 0.3);
+var HAIKU_5_5 = price(0.1, 0.5, 0.01, {
+  longContext: { threshold: 1e5, input: 0.5, output: 2.5 }
+});
+var HAIKU_4_5 = price(1, 5, 0.1);
+var HAIKU_3_5 = price(0.8, 4, 0.08);
+var FAMILIES = [
+  ["fable-5-1", FABLE_5_1],
+  ["mythos-5-1", FABLE_5_1],
+  ["fable-5", FABLE_5],
+  ["mythos-5", FABLE_5],
+  ["opus-5-5", OPUS_5_5],
+  ["opus-5", OPUS_5],
+  ["opus-4-8", OPUS_4_LATE],
+  ["opus-4-7", OPUS_4_LATE],
+  ["opus-4-6", OPUS_4_LATE],
+  ["opus-4-5", OPUS_4_LATE],
+  ["opus-4-1", OPUS_4_EARLY],
+  ["opus-4", OPUS_4_EARLY],
+  ["sonnet-5-5", SONNET_5_5],
+  ["sonnet-5", SONNET_5],
+  ["sonnet-4-6", SONNET_4],
+  ["sonnet-4-5", SONNET_4],
+  ["sonnet-4", SONNET_4],
+  ["haiku-5-5", HAIKU_5_5],
+  ["haiku-4-5", HAIKU_4_5],
+  ["3-5-haiku", HAIKU_3_5]
+];
+var ALIASES = [
+  ["fable", FABLE_5_1],
+  ["mythos", FABLE_5_1],
+  ["opus", OPUS_5_5],
+  ["sonnet", SONNET_5_5],
+  ["haiku", HAIKU_4_5]
+];
+function bundledPrice(id) {
+  for (const [pattern, p] of FAMILIES) if (id.includes(pattern)) return p;
+  if (/\d/.test(id)) return void 0;
+  for (const [pattern, p] of ALIASES) if (id.includes(pattern)) return p;
+  return void 0;
+}
+function finite(n) {
+  return typeof n === "number" && Number.isFinite(n) && n >= 0;
+}
+function resolvePrice(model, overrides) {
+  const id = String(model ?? "").toLowerCase();
+  if (!id) return void 0;
+  const base = bundledPrice(id);
+  if (!overrides) return base;
+  for (const [pattern, o] of Object.entries(overrides)) {
+    if (!pattern || !id.includes(pattern.toLowerCase())) continue;
+    const input2 = finite(o.input) ? o.input : base?.input;
+    const output2 = finite(o.output) ? o.output : base?.output;
+    if (input2 === void 0 || output2 === void 0) return base;
+    const merged = {
+      input: input2,
+      output: output2,
+      cacheWrite5m: finite(o.cacheWrite5m) ? o.cacheWrite5m : base && !finite(o.input) ? base.cacheWrite5m : input2 * 1.25,
+      cacheWrite1h: finite(o.cacheWrite1h) ? o.cacheWrite1h : base && !finite(o.input) ? base.cacheWrite1h : input2 * 2,
+      cacheRead: finite(o.cacheRead) ? o.cacheRead : base && !finite(o.input) ? base.cacheRead : input2 * 0.1,
+      webSearch: finite(o.webSearch) ? o.webSearch : base?.webSearch ?? WEB_SEARCH_PER_1K
+    };
+    if (o.longContext) merged.longContext = o.longContext;
+    else if (base?.longContext) merged.longContext = base.longContext;
+    return merged;
+  }
+  return base;
+}
+var tok = (n) => finite(n) ? n : 0;
+function costOfCall(call, price2) {
+  const input2 = tok(call.input_tokens);
+  const output2 = tok(call.output_tokens);
+  const c5m = tok(call.cache_create_5m);
+  const c1h = tok(call.cache_create_1h);
+  const read = tok(call.cache_read);
+  const searches = tok(call.web_searches);
+  let p = price2;
+  const lc = price2.longContext;
+  if (lc && input2 + c5m + c1h + read > lc.threshold) {
+    const ratio = price2.input > 0 ? lc.input / price2.input : 1;
+    p = {
+      ...price2,
+      input: lc.input,
+      output: lc.output,
+      cacheWrite5m: price2.cacheWrite5m * ratio,
+      cacheWrite1h: price2.cacheWrite1h * ratio,
+      cacheRead: price2.cacheRead * ratio
+    };
+  }
+  const M = 1e6;
+  const breakdown = {
+    input: input2 * p.input / M,
+    output: output2 * p.output / M,
+    cacheWrite: (c5m * p.cacheWrite5m + c1h * p.cacheWrite1h) / M,
+    cacheRead: read * p.cacheRead / M,
+    tools: searches / 1e3 * (p.webSearch ?? 0)
+  };
+  return {
+    ...breakdown,
+    total: breakdown.input + breakdown.output + breakdown.cacheWrite + breakdown.cacheRead + breakdown.tools
+  };
+}
+function formatUsd(n) {
+  if (!Number.isFinite(n) || n === 0) return "$0.00";
+  const sign = n < 0 ? "-" : "";
+  const v = Math.abs(n);
+  if (v < 1e-4) return sign ? "-$0.0001" : "<$0.0001";
+  if (v < 1) {
+    const fixed = v.toFixed(4);
+    if (fixed.startsWith("1")) return `${sign}$1.00`;
+    return `${sign}$${fixed.replace(/0+$/, "").replace(/\.(\d)$/, ".$10")}`;
+  }
+  const two = v.toFixed(2);
+  if (Number(two) >= 1e3) return `${sign}$${Math.round(v).toLocaleString("en-US")}`;
+  return `${sign}$${two}`;
+}
+function estTokensFromChars(chars) {
+  return finite(chars) ? Math.ceil(chars / 4) : 0;
+}
+
+// src/usage/aggregate.ts
+var num = (n) => typeof n === "number" && Number.isFinite(n) ? n : 0;
+var isRealCall = (c) => c.model !== "<synthetic>";
+function totals(calls) {
+  const t = {
+    calls: 0,
+    input: 0,
+    output: 0,
+    cacheCreate5m: 0,
+    cacheCreate1h: 0,
+    cacheRead: 0,
+    thinking: 0,
+    costUsd: 0,
+    unpricedCalls: 0,
+    cacheHitRate: 0,
+    models: {}
+  };
+  for (const c of calls) {
+    if (!isRealCall(c)) continue;
+    t.calls += 1;
+    t.input += num(c.input_tokens);
+    t.output += num(c.output_tokens);
+    t.cacheCreate5m += num(c.cache_create_5m);
+    t.cacheCreate1h += num(c.cache_create_1h);
+    t.cacheRead += num(c.cache_read);
+    t.thinking += num(c.thinking_tokens);
+    if (c.priced && c.cost_usd != null && Number.isFinite(c.cost_usd)) t.costUsd += c.cost_usd;
+    else t.unpricedCalls += 1;
+    const m = c.model || "unknown";
+    t.models[m] = (t.models[m] ?? 0) + 1;
+  }
+  const denom = t.input + t.cacheCreate5m + t.cacheCreate1h + t.cacheRead;
+  t.cacheHitRate = denom > 0 ? t.cacheRead / denom : 0;
+  return t;
+}
+function groupBy(calls, keyFn) {
+  const buckets = /* @__PURE__ */ new Map();
+  for (const c of calls) {
+    if (!isRealCall(c)) continue;
+    const k = keyFn(c);
+    if (k == null) continue;
+    const list = buckets.get(k);
+    if (list) list.push(c);
+    else buckets.set(k, [c]);
+  }
+  return [...buckets.entries()].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, rows]) => ({ key, totals: totals(rows) }));
+}
+var fmtCache = /* @__PURE__ */ new Map();
+function formatter(tz) {
+  const key = tz ?? "";
+  let f = fmtCache.get(key);
+  if (!f) {
+    f = new Intl.DateTimeFormat("en-CA", {
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+      ...tz ? { timeZone: tz } : {}
+    });
+    fmtCache.set(key, f);
+  }
+  return f;
+}
+function localYmd(ts, tz) {
+  const parts = formatter(tz).formatToParts(new Date(ts));
+  const get = (type) => Number(parts.find((p) => p.type === type)?.value ?? 0);
+  return { y: get("year"), m: get("month"), d: get("day") };
+}
+var pad2 = (n) => String(n).padStart(2, "0");
+var ymdKey = ({ y, m, d }) => `${y}-${pad2(m)}-${pad2(d)}`;
+function dayKey(ts, tz) {
+  return ymdKey(localYmd(ts, tz));
+}
+function byAgent(calls) {
+  const mainRows = calls.filter((c) => !c.sidechain);
+  const side = calls.filter((c) => !!c.sidechain);
+  const main2 = totals(mainRows);
+  const subagents = groupBy(side, (c) => c.agent_id || "unknown").map((g) => ({ agentId: g.key, totals: g.totals })).sort((a, b) => b.totals.costUsd - a.totals.costUsd || b.totals.calls - a.totals.calls);
+  const subCost = subagents.reduce((s, a) => s + a.totals.costUsd, 0);
+  const total = main2.costUsd + subCost;
+  return { main: main2, subagents, delegationShare: total > 0 ? subCost / total : 0 };
+}
+
+// src/usage/insights.ts
+init_esm_shims();
+
+// src/usage/savings.ts
+init_esm_shims();
+var FALLBACK_MODEL = "claude-sonnet-5-5";
+
+// src/usage/insights.ts
+var THRASH_WRITE_SHARE = 0.2;
+var THRASH_RUN = 3;
+var TTL_5M_MS = 5 * 6e4;
+var TTL_1H_MS = 60 * 6e4;
+var COLD_WRITE_SHARE = 0.5;
+var BLOAT_TOKENS = 8e3;
+var BLOAT_TOOLS = /* @__PURE__ */ new Set(["Read", "Bash", "Grep", "WebFetch", "Glob"]);
+var CHURN_COMPACTIONS = 3;
+var CHURN_EARLY_SHARE = 0.5;
+var DEFAULT_WINDOW = 2e5;
+var TRIVIAL_OUTPUT = 100;
+var TRIVIAL_SHARE = 0.3;
+var MIN_PREMIUM_CALLS = 5;
+var FAST_COST_SHARE = 0.25;
+var THINKING_SHARE = 0.4;
+var MIN_OUTPUT_FOR_THINKING = 1e3;
+var DELEGATION_SHARE = 0.6;
+var DEFAULT_TURN_USD = 1;
+var ERROR_RUN = 3;
+var NEAR_LIMIT_PCT = 85;
+var NEAR_LIMIT_HIGH = 95;
+var num2 = (n) => typeof n === "number" && Number.isFinite(n) ? n : 0;
+var pct = (x) => `${Math.round(x * 100)}%`;
+var usd = (n) => n >= 1 ? `$${n.toFixed(2)}` : `$${n.toFixed(3)}`;
+var round4 = (n) => Math.round(n * 1e4) / 1e4;
+var clamp = (n) => Math.max(0, Math.min(100, Math.round(n)));
+var fmtK = (n) => n >= 1e6 ? `${(n / 1e6).toFixed(1)}M` : n >= 1e3 ? `${Math.round(n / 1e3)}k` : `${n}`;
+var contextOf = (c) => num2(c.input_tokens) + num2(c.cache_create_5m) + num2(c.cache_create_1h) + num2(c.cache_read);
+var writesOf = (c) => num2(c.cache_create_5m) + num2(c.cache_create_1h);
+var costOf = (c) => c.priced && c.cost_usd != null && Number.isFinite(c.cost_usd) ? c.cost_usd : 0;
+var isPremium = (model) => /opus|fable|mythos/i.test(model);
+function threads(calls) {
+  const out = /* @__PURE__ */ new Map();
+  for (const c of calls) {
+    const key = `${c.session_id}\0${c.sidechain ? c.agent_id ?? "sidechain" : ""}`;
+    const list = out.get(key);
+    if (list) list.push(c);
+    else out.set(key, [c]);
+  }
+  for (const list of out.values()) list.sort((a, b) => a.ts - b.ts);
+  return out;
+}
+function groupBySession(rows) {
+  const out = /* @__PURE__ */ new Map();
+  for (const r of rows) {
+    const list = out.get(r.session_id);
+    if (list) list.push(r);
+    else out.set(r.session_id, [r]);
+  }
+  return out;
+}
+function dominantModel(calls) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const c of calls) counts.set(c.model, (counts.get(c.model) ?? 0) + 1);
+  let best;
+  let n = 0;
+  for (const [m, k] of counts)
+    if (k > n) {
+      best = m;
+      n = k;
+    }
+  return best;
+}
+function writePrice(c, p) {
+  return num2(c.cache_create_1h) > num2(c.cache_create_5m) ? p.cacheWrite1h : p.cacheWrite5m;
+}
+function scopeFor(sessionIds) {
+  const ids = [...new Set(sessionIds)];
+  return ids.length === 1 ? { scope: "session", sessionId: ids[0] } : { scope: "project" };
+}
+function withScope(base, sessionIds) {
+  const s = scopeFor(sessionIds);
+  const out = { ...base, scope: s.scope };
+  if (s.sessionId) out.sessionId = s.sessionId;
+  return out;
+}
+var SEVERITY_RANK = { high: 0, warn: 1, info: 2 };
+function hasCompactionBetween(ctx, sessionId, from, to) {
+  const list = ctx.compactionsBySession.get(sessionId);
+  if (!list) return false;
+  return list.some((t) => t > from && t <= to);
+}
+function detectCacheThrash(ctx) {
+  let runs = 0;
+  let longest = 0;
+  let rewritten = 0;
+  let savings = 0;
+  const sessions = /* @__PURE__ */ new Set();
+  for (const list of ctx.threads.values()) {
+    let run = [];
+    const flush = () => {
+      if (run.length >= THRASH_RUN) {
+        runs += 1;
+        longest = Math.max(longest, run.length);
+        for (const c of run) {
+          const w = writesOf(c);
+          rewritten += w;
+          sessions.add(c.session_id);
+          const p = ctx.priceOf(c.model);
+          if (p) savings += w * (writePrice(c, p) - p.cacheRead) / 1e6;
+        }
+      }
+      run = [];
+    };
+    for (let i = 1; i < list.length; i++) {
+      const c = list[i];
+      const prev = list[i - 1];
+      const ctxTokens = contextOf(c);
+      const heavy = ctxTokens > 0 && writesOf(c) / ctxTokens >= THRASH_WRITE_SHARE;
+      const broken = hasCompactionBetween(ctx, c.session_id, prev.ts, c.ts) || c.ts - prev.ts > ttlFor(list);
+      if (!heavy || broken) {
+        flush();
+        continue;
+      }
+      run.push(c);
+    }
+    flush();
+  }
+  if (runs === 0) return void 0;
+  return withScope(
+    {
+      id: "cache-thrash",
+      severity: runs >= 3 || rewritten >= 5e5 ? "high" : "warn",
+      title: "Prompt cache keeps being rewritten",
+      reason: `${runs} run${runs === 1 ? "" : "s"} of ${THRASH_RUN}+ consecutive calls rewrote \u2265 ${pct(THRASH_WRITE_SHARE)} of their context (longest run ${longest} calls, ${fmtK(rewritten)} tokens written again).`,
+      evidence: { runs, longestRun: longest, tokensRewritten: rewritten },
+      estimatedSavingsUsd: round4(savings),
+      recommendation: "Something early in the prompt changes every turn (system prompt, tool list, a file re-read with a timestamp); keep the stable prefix stable so later calls hit the cache."
+    },
+    sessions
+  );
+}
+function ttlFor(list) {
+  let w5 = 0;
+  let w1 = 0;
+  for (const c of list) {
+    w5 += num2(c.cache_create_5m);
+    w1 += num2(c.cache_create_1h);
+  }
+  return w1 > w5 ? TTL_1H_MS : TTL_5M_MS;
+}
+function detectCacheCold(ctx) {
+  let restarts = 0;
+  let rewritten = 0;
+  let savings = 0;
+  let longestGap = 0;
+  const sessions = /* @__PURE__ */ new Set();
+  for (const list of ctx.threads.values()) {
+    const ttl = ttlFor(list);
+    for (let i = 1; i < list.length; i++) {
+      const c = list[i];
+      const prev = list[i - 1];
+      const gap = c.ts - prev.ts;
+      if (gap <= ttl) continue;
+      if (hasCompactionBetween(ctx, c.session_id, prev.ts, c.ts)) continue;
+      const ctxTokens = contextOf(c);
+      const w = writesOf(c);
+      if (ctxTokens === 0 || w / ctxTokens < COLD_WRITE_SHARE) continue;
+      restarts += 1;
+      rewritten += w;
+      longestGap = Math.max(longestGap, gap);
+      sessions.add(c.session_id);
+      const p = ctx.priceOf(c.model);
+      if (p) savings += w * (writePrice(c, p) - p.cacheRead) / 1e6;
+    }
+  }
+  if (restarts === 0) return void 0;
+  const minutes = Math.round(longestGap / 6e4);
+  return withScope(
+    {
+      id: "cache-cold",
+      severity: restarts >= 2 ? "warn" : "info",
+      title: `Cache went cold ${restarts === 1 ? "once" : `${restarts} times`}`,
+      reason: `${restarts} pause${restarts === 1 ? "" : "s"} longer than the cache TTL (longest ${minutes} min) forced ${fmtK(rewritten)} tokens to be written to cache again (~${usd(savings)}).`,
+      evidence: { restarts, tokensRewritten: rewritten, longestGapMinutes: minutes },
+      estimatedSavingsUsd: round4(savings),
+      recommendation: "Long pauses mid-session re-pay the cache write; for walk-away breaks start a new session, or keep the turn cadence inside the TTL."
+    },
+    sessions
+  );
+}
+function detectContextBloat(ctx) {
+  const bySession = groupBySession(ctx.calls);
+  const modelFor = /* @__PURE__ */ new Map();
+  for (const [sid, rows] of bySession) modelFor.set(sid, dominantModel(rows));
+  let count = 0;
+  let tokens = 0;
+  let savings = 0;
+  const byTool = /* @__PURE__ */ new Map();
+  const sessions = /* @__PURE__ */ new Set();
+  for (const u of ctx.toolUses) {
+    if (!BLOAT_TOOLS.has(u.tool)) continue;
+    const est = estTokensFromChars(num2(u.result_chars));
+    if (est <= BLOAT_TOKENS) continue;
+    count += 1;
+    tokens += est;
+    byTool.set(u.tool, (byTool.get(u.tool) ?? 0) + 1);
+    sessions.add(u.session_id);
+    const p = ctx.priceOf(modelFor.get(u.session_id) ?? FALLBACK_MODEL) ?? ctx.priceOf(FALLBACK_MODEL);
+    if (p) {
+      const later = ctx.laterCalls(u.session_id, u.ts);
+      savings += (est * p.cacheWrite5m + est * p.cacheRead * later) / 1e6;
+    }
+  }
+  if (count === 0) return void 0;
+  const top = [...byTool.entries()].sort((a, b) => b[1] - a[1])[0];
+  return withScope(
+    {
+      id: "context-bloat",
+      severity: count >= 5 || tokens >= 1e5 ? "high" : "warn",
+      title: "Oversized tool results in context",
+      reason: `${count} ${[...byTool.keys()].join("/")} result${count === 1 ? "" : "s"} above ${fmtK(BLOAT_TOKENS)} tokens put ~${fmtK(tokens)} tokens into context (mostly ${top[0]}, ${top[1]}\xD7), re-read on every later call.`,
+      evidence: { results: count, estTokens: tokens, topTool: top[0], topToolCount: top[1] },
+      estimatedSavingsUsd: round4(savings),
+      recommendation: "Route large outputs through em_execute / em_execute_file / em_search so only the matching sections come back."
+    },
+    sessions
+  );
+}
+function detectCompactionChurn(ctx) {
+  const windowFor = /* @__PURE__ */ new Map();
+  for (const s of ctx.snapshots) {
+    if (num2(s.ctx_size) > 0) {
+      const prev = windowFor.get(s.session_id);
+      if (prev === void 0) windowFor.set(s.session_id, num2(s.ctx_size));
+    }
+  }
+  let worstSession;
+  let worstCount = 0;
+  let early = 0;
+  const sessions = /* @__PURE__ */ new Set();
+  for (const [sid, evs] of groupBySession(ctx.contextEvents)) {
+    const compactions = evs.filter((e) => e.kind === "compact");
+    const window2 = windowFor.get(sid) ?? DEFAULT_WINDOW;
+    const earlyHere = compactions.filter(
+      (e) => e.pre_tokens != null && e.pre_tokens > 0 && e.pre_tokens < window2 * CHURN_EARLY_SHARE
+    ).length;
+    if (compactions.length >= CHURN_COMPACTIONS || earlyHere > 0) {
+      sessions.add(sid);
+      early += earlyHere;
+      if (compactions.length > worstCount) {
+        worstCount = compactions.length;
+        worstSession = sid;
+      }
+    }
+  }
+  if (sessions.size === 0) return void 0;
+  return withScope(
+    {
+      id: "compaction-churn",
+      severity: worstCount >= CHURN_COMPACTIONS * 2 ? "high" : "warn",
+      title: "Frequent context compactions",
+      reason: `${sessions.size} session${sessions.size === 1 ? "" : "s"} compacted repeatedly (up to ${worstCount} times in ${(worstSession ?? "").slice(0, 8)}; ${early} below ${pct(CHURN_EARLY_SHARE)} of the window).`,
+      evidence: { sessions: sessions.size, maxCompactions: worstCount, earlyCompactions: early },
+      recommendation: "Each compaction rewrites the whole cache and loses detail; keep raw output out of context (em_* tools) and split long tasks into sessions."
+    },
+    sessions
+  );
+}
+function detectOpusForTrivial(ctx) {
+  const toolRequests = /* @__PURE__ */ new Set();
+  for (const u of ctx.toolUses) if (u.request_id) toolRequests.add(u.request_id);
+  const premium = ctx.calls.filter((c) => isPremium(c.model));
+  if (premium.length < MIN_PREMIUM_CALLS) return void 0;
+  const trivial = premium.filter(
+    (c) => num2(c.output_tokens) < TRIVIAL_OUTPUT && c.stop_reason !== "tool_use" && !toolRequests.has(c.request_id)
+  );
+  const share = trivial.length / premium.length;
+  if (share <= TRIVIAL_SHARE) return void 0;
+  const sonnet = resolvePrice(FALLBACK_MODEL, ctx.overrides);
+  let spent = 0;
+  let repriced = 0;
+  for (const c of trivial) {
+    spent += costOf(c);
+    if (sonnet) repriced += costOfCall(c, sonnet).total;
+  }
+  const savings = Math.max(0, spent - repriced);
+  return withScope(
+    {
+      id: "opus-for-trivial",
+      severity: share >= 0.6 ? "warn" : "info",
+      title: "Premium model on trivial turns",
+      reason: `${trivial.length} of ${premium.length} premium-model calls (${pct(share)}) produced under ${TRIVIAL_OUTPUT} output tokens with no tool use, costing ${usd(spent)} (~${usd(repriced)} at Sonnet).`,
+      evidence: {
+        trivialCalls: trivial.length,
+        premiumCalls: premium.length,
+        share: Math.round(share * 100),
+        spentUsd: round4(spent)
+      },
+      estimatedSavingsUsd: round4(savings),
+      recommendation: "Short acknowledgements and lookups do not need the premium model; delegate routine turns to a Sonnet/Haiku subagent or switch model for simple work."
+    },
+    trivial.map((c) => c.session_id)
+  );
+}
+function detectFastModeShare(ctx) {
+  let fast = 0;
+  let fastCalls = 0;
+  let total = 0;
+  const sessions = /* @__PURE__ */ new Set();
+  for (const c of ctx.calls) {
+    const cost = costOf(c);
+    total += cost;
+    if (c.speed === "fast") {
+      fast += cost;
+      fastCalls += 1;
+      sessions.add(c.session_id);
+    }
+  }
+  if (total <= 0) return void 0;
+  const share = fast / total;
+  if (share <= FAST_COST_SHARE) return void 0;
+  return withScope(
+    {
+      id: "fast-mode-share",
+      severity: "info",
+      title: "Fast mode is a large share of spend",
+      reason: `${fastCalls} fast-mode calls account for ${usd(fast)} of ${usd(total)} (${pct(share)}) of priced cost.`,
+      evidence: {
+        fastCalls,
+        fastUsd: round4(fast),
+        totalUsd: round4(total),
+        share: Math.round(share * 100)
+      },
+      recommendation: "Fast mode is billed at a premium; reserve it for interactive turns where latency matters."
+    },
+    sessions
+  );
+}
+function detectThinkingShare(ctx) {
+  const t = totals(ctx.calls);
+  if (t.output < MIN_OUTPUT_FOR_THINKING || t.thinking <= 0) return void 0;
+  const share = t.thinking / t.output;
+  if (share <= THINKING_SHARE) return void 0;
+  return withScope(
+    {
+      id: "thinking-share",
+      severity: "info",
+      title: "Most output tokens are thinking",
+      reason: `${fmtK(t.thinking)} of ${fmtK(t.output)} output tokens (${pct(share)}) were thinking, billed at the output rate.`,
+      evidence: {
+        thinkingTokens: t.thinking,
+        outputTokens: t.output,
+        share: Math.round(share * 100)
+      },
+      recommendation: "Lower the effort level for routine edits and lookups; keep high effort for design and debugging."
+    },
+    ctx.calls.map((c) => c.session_id)
+  );
+}
+function detectSubagentCost(ctx) {
+  const a = byAgent(ctx.calls);
+  if (a.delegationShare <= DELEGATION_SHARE) return void 0;
+  const subCost = a.subagents.reduce((s, x) => s + x.totals.costUsd, 0);
+  const subCalls = a.subagents.reduce((s, x) => s + x.totals.calls, 0);
+  return withScope(
+    {
+      id: "subagent-cost",
+      severity: "info",
+      title: "Subagents dominate spend",
+      reason: `${a.subagents.length} subagent${a.subagents.length === 1 ? "" : "s"} made ${subCalls} calls for ${usd(subCost)}, ${pct(a.delegationShare)} of priced cost (main thread ${usd(a.main.costUsd)}).`,
+      evidence: {
+        subagents: a.subagents.length,
+        subagentCalls: subCalls,
+        subagentUsd: round4(subCost),
+        share: Math.round(a.delegationShare * 100)
+      },
+      recommendation: "Check that subagents run on the cheapest model that fits (model: sonnet/haiku) and return summaries, not transcripts."
+    },
+    ctx.calls.filter((c) => c.sidechain).map((c) => c.session_id)
+  );
+}
+var DRIVER_ADVICE = {
+  "cache-write": {
+    what: "cache writes",
+    recommendation: "Cache writes dominate: a long idle gap or a cache-busting change (edited system prompt, reordered tools) re-wrote the prefix. Keep the prefix stable, or use the 1h cache deliberately for long pauses."
+  },
+  output: {
+    what: "output",
+    recommendation: "Output dominates: a long answer or heavy thinking. Lower the effort level or ask for a shorter answer; keep high effort for design and debugging."
+  },
+  context: {
+    what: "context",
+    recommendation: "Context dominates: the call re-read a large conversation. Compact, start a fresh session, or move the bulk into a subagent."
+  }
+};
+function detectExpensiveTurn(ctx) {
+  const limit = ctx.budgets.turnUsd ?? DEFAULT_TURN_USD;
+  const hits = ctx.calls.filter((c) => costOf(c) > limit).sort((a, b2) => costOf(b2) - costOf(a));
+  if (hits.length === 0) return void 0;
+  const top = hits[0];
+  const price2 = ctx.priceOf(top.model);
+  const b = price2 ? costOfCall(top, price2) : { input: 0, output: 0, cacheWrite: 0, cacheRead: 0, tools: 0, total: costOf(top) };
+  const contextUsd = b.input + b.cacheRead;
+  const driver = b.cacheWrite > b.output && b.cacheWrite > contextUsd ? "cache-write" : b.output > contextUsd ? "output" : "context";
+  const advice = DRIVER_ADVICE[driver];
+  const n = hits.length;
+  return withScope(
+    {
+      id: "expensive-turn",
+      severity: costOf(top) > limit * 3 ? "high" : "warn",
+      title: `${n} call${n === 1 ? "" : "s"} over ${usd(limit)}`,
+      reason: `${n} call${n === 1 ? "" : "s"} cost more than ${usd(limit)} each; the largest was ${usd(costOf(top))} on ${top.model} with ${fmtK(contextOf(top))} context tokens, driven by ${advice.what} (context ${usd(contextUsd)}, output ${usd(b.output)}, cache writes ${usd(b.cacheWrite)}).`,
+      evidence: {
+        calls: n,
+        maxUsd: round4(costOf(top)),
+        model: top.model,
+        contextTokens: contextOf(top),
+        limitUsd: limit,
+        driver,
+        contextUsd: round4(contextUsd),
+        outputUsd: round4(b.output),
+        cacheWriteUsd: round4(b.cacheWrite)
+      },
+      recommendation: advice.recommendation
+    },
+    hits.map((c) => c.session_id)
+  );
+}
+function detectErrorLoop(ctx) {
+  const loops = ctx.events.filter((e) => e.category === "iteration_loop");
+  const sessions = new Set(loops.map((e) => e.session_id));
+  let worstTool = "";
+  let worstRun = 0;
+  const byThread = /* @__PURE__ */ new Map();
+  for (const u of ctx.toolUses) {
+    const key = `${u.session_id}\0${u.agent_id ?? ""}`;
+    const list = byThread.get(key);
+    if (list) list.push(u);
+    else byThread.set(key, [u]);
+  }
+  for (const list of byThread.values()) {
+    list.sort((a, b) => a.ts - b.ts);
+    let run = 0;
+    let tool = "";
+    for (const u of list) {
+      if (u.is_error && u.tool === tool) run += 1;
+      else {
+        run = u.is_error ? 1 : 0;
+        tool = u.is_error ? u.tool : "";
+      }
+      if (run >= ERROR_RUN) {
+        sessions.add(u.session_id);
+        if (run > worstRun) {
+          worstRun = run;
+          worstTool = tool;
+        }
+      }
+    }
+  }
+  if (loops.length === 0 && worstRun === 0) return void 0;
+  const parts = [];
+  if (loops.length)
+    parts.push(`${loops.length} repeated-call loop${loops.length === 1 ? "" : "s"} recorded`);
+  if (worstRun) parts.push(`${worstRun} consecutive ${worstTool} failures`);
+  return withScope(
+    {
+      id: "error-loop",
+      severity: "warn",
+      title: "Repeated failures or loops",
+      reason: `${parts.join(" and ")}; every retry re-reads the whole context.`,
+      evidence: { loops: loops.length, longestErrorRun: worstRun, tool: worstTool },
+      recommendation: "After two identical failures stop and change approach (em_recall for an earlier fix, read the error, try a different tool)."
+    },
+    sessions
+  );
+}
+function detectBudget(ctx) {
+  const out = [];
+  const { sessionUsd, dailyUsd } = ctx.budgets;
+  if (sessionUsd) {
+    for (const [sid, rows] of groupBySession(ctx.calls)) {
+      const cost = totals(rows).costUsd;
+      if (cost <= sessionUsd) continue;
+      out.push({
+        id: "budget",
+        severity: "high",
+        title: "Session budget exceeded",
+        reason: `Session ${sid.slice(0, 8)} has cost ${usd(cost)}, over the ${usd(sessionUsd)} session budget (${pct(cost / sessionUsd)}).`,
+        evidence: { sessionUsd: round4(cost), budgetUsd: sessionUsd },
+        scope: "session",
+        sessionId: sid
+      });
+    }
+  }
+  if (dailyUsd) {
+    const today = dayKey(ctx.now);
+    const cost = totals(ctx.calls.filter((c) => dayKey(c.ts) === today)).costUsd;
+    if (cost > dailyUsd)
+      out.push({
+        id: "budget",
+        severity: "high",
+        title: "Daily budget exceeded",
+        reason: `Today (${today}) has cost ${usd(cost)}, over the ${usd(dailyUsd)} daily budget (${pct(cost / dailyUsd)}).`,
+        evidence: { day: today, todayUsd: round4(cost), budgetUsd: dailyUsd },
+        scope: "project"
+      });
+  }
+  return out;
+}
+function detectUnpricedModel(ctx) {
+  const unpriced = ctx.calls.filter((c) => !c.priced);
+  if (unpriced.length === 0) return void 0;
+  const models = [...new Set(unpriced.map((c) => c.model || "unknown"))];
+  return withScope(
+    {
+      id: "unpriced-model",
+      severity: "info",
+      title: "Some calls are unpriced",
+      reason: `${unpriced.length} of ${ctx.calls.length} calls use ${models.length} model${models.length === 1 ? "" : "s"} without a price (${models.slice(0, 3).join(", ")}), so cost totals undercount.`,
+      evidence: { calls: unpriced.length, models: models.join(", ") },
+      recommendation: 'Add the model to config.usage.pricing, e.g. {"pricing": {"<model substring>": {"input": 3, "output": 15}}} (USD per MTok).'
+    },
+    unpriced.map((c) => c.session_id)
+  );
+}
+function detectContextNearLimit(ctx) {
+  let latest;
+  for (const s of ctx.snapshots) if (!latest || s.ts > latest.ts) latest = s;
+  if (!latest || latest.ctx_used_pct == null || latest.ctx_used_pct < NEAR_LIMIT_PCT)
+    return void 0;
+  const p = latest.ctx_used_pct;
+  return {
+    id: "context-near-limit",
+    severity: p >= NEAR_LIMIT_HIGH ? "high" : "warn",
+    title: "Context window nearly full",
+    reason: `The latest statusline reports ${Math.round(p)}% of the ${fmtK(num2(latest.ctx_size) || DEFAULT_WINDOW)}-token window in use; the next compaction is close.`,
+    evidence: { ctxUsedPct: Math.round(p), ctxSize: num2(latest.ctx_size) },
+    recommendation: "Save durable findings with em_remember now, then compact or start a fresh session.",
+    scope: "session",
+    sessionId: latest.session_id
+  };
+}
+function findInsight(insights, id) {
+  return insights.find((i) => i.id === id);
+}
+var ev2 = (i, key) => {
+  const v = i?.evidence?.[key];
+  return typeof v === "number" ? v : 0;
+};
+function scoreContextHealth(ctx, insights) {
+  const reasons = [];
+  let v = 100;
+  const bloat = ev2(findInsight(insights, "context-bloat"), "results");
+  if (bloat) {
+    const d = Math.min(30, bloat * 5);
+    v -= d;
+    reasons.push(`${bloat} oversized tool result${bloat === 1 ? "" : "s"} in context (\u2212${d})`);
+  }
+  let extra = 0;
+  for (const evs of groupBySession(ctx.contextEvents).values())
+    extra += Math.max(0, evs.filter((e) => e.kind === "compact").length - 1);
+  if (extra) {
+    const d = Math.min(30, extra * 10);
+    v -= d;
+    reasons.push(
+      `${extra} compaction${extra === 1 ? "" : "s"} beyond the first per session (\u2212${d})`
+    );
+  }
+  const near = findInsight(insights, "context-near-limit");
+  if (near) {
+    v -= 20;
+    reasons.push(`context ${ev2(near, "ctxUsedPct")}% full (\u221220)`);
+  }
+  const loop = findInsight(insights, "error-loop");
+  if (loop) {
+    const n = ev2(loop, "loops") + (ev2(loop, "longestErrorRun") ? 1 : 0);
+    const d = Math.min(20, n * 10);
+    v -= d;
+    reasons.push(`${n} error loop${n === 1 ? "" : "s"} (\u2212${d})`);
+  }
+  if (!reasons.length)
+    reasons.push(
+      ctx.calls.length ? "no oversized results, compaction churn or loops" : "no usage recorded yet"
+    );
+  return { id: "context-health", value: clamp(v), reasons };
+}
+function scoreCostEfficiency(ctx, insights) {
+  const reasons = [];
+  let v = 100;
+  const trivial = findInsight(insights, "opus-for-trivial");
+  if (trivial) {
+    const d = Math.round(ev2(trivial, "share") / 100 * 50);
+    v -= d;
+    reasons.push(`${ev2(trivial, "share")}% of premium-model calls were trivial (\u2212${d})`);
+  }
+  const fast = findInsight(insights, "fast-mode-share");
+  if (fast) {
+    const d = Math.round(ev2(fast, "share") / 100 * 40);
+    v -= d;
+    reasons.push(`fast mode is ${ev2(fast, "share")}% of spend (\u2212${d})`);
+  }
+  const exp = findInsight(insights, "expensive-turn");
+  if (exp) {
+    const n = ev2(exp, "calls");
+    const d = Math.min(30, n * 10);
+    v -= d;
+    reasons.push(`${n} call${n === 1 ? "" : "s"} over ${usd(ev2(exp, "limitUsd"))} (\u2212${d})`);
+  }
+  const unpriced = findInsight(insights, "unpriced-model");
+  if (unpriced && ctx.calls.length) {
+    const share = ev2(unpriced, "calls") / ctx.calls.length;
+    const d = Math.round(share * 20);
+    v -= d;
+    reasons.push(`${pct(share)} of calls unpriced (\u2212${d})`);
+  }
+  const budgets = insights.filter((i) => i.id === "budget").length;
+  if (budgets) {
+    const d = Math.min(40, budgets * 20);
+    v -= d;
+    reasons.push(`${budgets} budget${budgets === 1 ? "" : "s"} exceeded (\u2212${d})`);
+  }
+  if (!reasons.length)
+    reasons.push(
+      ctx.calls.length ? "no premium waste, fast-mode or budget issues" : "no usage recorded yet"
+    );
+  return { id: "cost-efficiency", value: clamp(v), reasons };
+}
+function scoreCacheEfficiency(ctx, insights) {
+  const reasons = [];
+  const t = totals(ctx.calls);
+  if (t.calls === 0)
+    return { id: "cache-efficiency", value: 0, reasons: ["no usage recorded yet"] };
+  let v = t.cacheHitRate * 100;
+  reasons.push(`cache hit rate ${pct(t.cacheHitRate)} over ${t.calls} calls`);
+  const cold = ev2(findInsight(insights, "cache-cold"), "restarts");
+  if (cold) {
+    const d = Math.min(25, cold * 5);
+    v -= d;
+    reasons.push(`${cold} cold restart${cold === 1 ? "" : "s"} (\u2212${d})`);
+  }
+  const thrash = ev2(findInsight(insights, "cache-thrash"), "runs");
+  if (thrash) {
+    const d = Math.min(30, thrash * 10);
+    v -= d;
+    reasons.push(`${thrash} cache-rewrite run${thrash === 1 ? "" : "s"} (\u2212${d})`);
+  }
+  return { id: "cache-efficiency", value: clamp(v), reasons };
+}
+function scoreDelegation(ctx) {
+  const reasons = [];
+  const a = byAgent(ctx.calls);
+  if (ctx.calls.length === 0)
+    return { id: "delegation", value: 0, reasons: ["no usage recorded yet"] };
+  if (a.subagents.length === 0)
+    return {
+      id: "delegation",
+      value: 60,
+      reasons: ["no subagent calls: the main thread carries every tool result itself"]
+    };
+  let v;
+  if (a.delegationShare <= DELEGATION_SHARE) {
+    v = 100;
+    reasons.push(
+      `subagents are ${pct(a.delegationShare)} of cost across ${a.subagents.length} agent${a.subagents.length === 1 ? "" : "s"}`
+    );
+  } else {
+    v = Math.max(20, 100 - 150 * (a.delegationShare - DELEGATION_SHARE));
+    reasons.push(
+      `subagents are ${pct(a.delegationShare)} of cost, above ${pct(DELEGATION_SHARE)} (\u2212${100 - Math.round(v)})`
+    );
+  }
+  const sub = totals(ctx.calls.filter((c) => c.sidechain));
+  if (sub.calls && sub.cacheHitRate < 0.5) {
+    v -= 15;
+    reasons.push(`subagent cache hit rate ${pct(sub.cacheHitRate)} (\u221215)`);
+  }
+  return { id: "delegation", value: clamp(v), reasons };
+}
+function detectInsights(input2) {
+  const calls = input2.calls.filter(isRealCall);
+  const compactionsBySession = /* @__PURE__ */ new Map();
+  for (const e of input2.contextEvents) {
+    const list = compactionsBySession.get(e.session_id);
+    if (list) list.push(e.ts);
+    else compactionsBySession.set(e.session_id, [e.ts]);
+  }
+  for (const list of compactionsBySession.values()) list.sort((a, b) => a - b);
+  const callTs = /* @__PURE__ */ new Map();
+  for (const [sid, rows] of groupBySession(calls))
+    callTs.set(
+      sid,
+      rows.map((c) => c.ts).sort((a, b) => a - b)
+    );
+  const priceCache = /* @__PURE__ */ new Map();
+  const overrides = input2.overrides;
+  const ctx = {
+    calls,
+    threads: threads(calls),
+    toolUses: input2.toolUses,
+    contextEvents: input2.contextEvents,
+    stats: input2.stats,
+    events: input2.events,
+    snapshots: input2.snapshots,
+    now: input2.now ?? Date.now(),
+    budgets: input2.budgets ?? {},
+    overrides,
+    priceOf: (model) => {
+      if (!priceCache.has(model)) priceCache.set(model, resolvePrice(model, overrides));
+      return priceCache.get(model);
+    },
+    compactionsBySession,
+    laterCalls: (sid, ts) => (callTs.get(sid) ?? []).filter((t) => t > ts).length
+  };
+  const insights = [];
+  const push = (i) => {
+    if (i) insights.push(i);
+  };
+  push(detectCacheThrash(ctx));
+  push(detectCacheCold(ctx));
+  push(detectContextBloat(ctx));
+  push(detectCompactionChurn(ctx));
+  push(detectOpusForTrivial(ctx));
+  push(detectFastModeShare(ctx));
+  push(detectThinkingShare(ctx));
+  push(detectSubagentCost(ctx));
+  push(detectExpensiveTurn(ctx));
+  push(detectErrorLoop(ctx));
+  for (const b of detectBudget(ctx)) push(b);
+  push(detectUnpricedModel(ctx));
+  push(detectContextNearLimit(ctx));
+  insights.sort(
+    (a, b) => SEVERITY_RANK[a.severity] - SEVERITY_RANK[b.severity] || (b.estimatedSavingsUsd ?? 0) - (a.estimatedSavingsUsd ?? 0) || a.id.localeCompare(b.id)
+  );
+  const scores = [
+    scoreContextHealth(ctx, insights),
+    scoreCostEfficiency(ctx, insights),
+    scoreCacheEfficiency(ctx, insights),
+    scoreDelegation(ctx)
+  ];
+  return { insights, scores };
+}
+var INSIGHT_EVENT_CATEGORIES = ["iteration_loop", "error", "tool_call"];
+function loadInsightInput(db, ctx, opts = {}) {
+  const filter = { sessionId: opts.sessionId, since: opts.since };
+  const usage = ctx.config.usage;
+  return {
+    calls: db.apiCalls(filter),
+    toolUses: db.toolUses(filter),
+    contextEvents: db.contextEvents(filter),
+    snapshots: db.statuslineSnapshots(filter),
+    stats: opts.sessionId ? db.statsBySession(opts.sessionId) : db.statsAll(),
+    events: opts.sessionId ? db.eventsBySession(opts.sessionId, { categories: INSIGHT_EVENT_CATEGORIES }) : db.eventsRecent(500, INSIGHT_EVENT_CATEGORIES).filter((e) => !opts.since || e.ts >= opts.since),
+    now: opts.now ?? Date.now(),
+    budgets: usage.budgets,
+    overrides: usage.pricing
+  };
+}
+
+// src/usage/brief.ts
+var DAY_MS = 864e5;
+function todaysCalls(db, now) {
+  const today = dayKey(now);
+  return db.apiCalls({ since: now - 1.5 * DAY_MS }).filter((c) => dayKey(c.ts) === today);
+}
+function usageBrief(db, ctx, opts = {}) {
+  const now = opts.now ?? Date.now();
+  const today = totals(todaysCalls(db, now));
+  const session = totals(opts.sessionId ? db.apiCalls({ sessionId: opts.sessionId }) : []);
+  const cacheHitRate = today.calls ? today.cacheHitRate : session.cacheHitRate;
+  const out = {
+    line: "",
+    sessionUsd: session.costUsd,
+    todayUsd: today.costUsd,
+    cacheHitRate
+  };
+  if (today.calls === 0 && session.calls === 0) return out;
+  const parts = [
+    `today ${formatUsd(today.costUsd)} (${today.calls} call${today.calls === 1 ? "" : "s"}, ${Math.round(cacheHitRate * 100)}% cache hits)`
+  ];
+  if (session.calls > 0) parts.push(`session ${formatUsd(session.costUsd)}`);
+  try {
+    const scope = session.calls > 0 ? { sessionId: opts.sessionId } : { since: now - 1.5 * DAY_MS };
+    const { insights } = detectInsights(loadInsightInput(db, ctx, { ...scope, now }));
+    const top = insights[0];
+    if (top) {
+      out.topInsight = top;
+      const saving = top.estimatedSavingsUsd && top.estimatedSavingsUsd >= 5e-3 ? ` (~${formatUsd(top.estimatedSavingsUsd)})` : "";
+      parts.push(`top insight: ${top.title.charAt(0).toLowerCase()}${top.title.slice(1)}${saving}`);
+    }
+  } catch {
+  }
+  out.line = `usage: ${parts.join(" \xB7 ")}`;
+  return out;
+}
+function budgetWarnings(db, ctx, sessionId, now = Date.now()) {
+  const { sessionUsd, dailyUsd } = ctx.config.usage.budgets;
+  if (!sessionUsd && !dailyUsd) return [];
+  const out = [];
+  if (sessionUsd) {
+    const key = `usage_alert:session:${sessionId}`;
+    const cost = totals(db.apiCalls({ sessionId })).costUsd;
+    if (cost >= sessionUsd && !db.metaGet(key)) {
+      db.metaSet(key, String(now));
+      out.push(
+        `eminiar usage \u2014 this session has cost ${formatUsd(cost)}, over its ${formatUsd(sessionUsd)} budget (config.usage.budgets.sessionUsd). Keep raw output out of context, delegate bulk work to a cheaper model, or start a fresh session.`
+      );
+    }
+  }
+  if (dailyUsd) {
+    const day = dayKey(now);
+    const key = `usage_alert:daily:${day}`;
+    const cost = totals(todaysCalls(db, now)).costUsd;
+    if (cost >= dailyUsd && !db.metaGet(key)) {
+      db.metaSet(key, String(now));
+      out.push(
+        `eminiar usage \u2014 today's sessions have cost ${formatUsd(cost)}, over the ${formatUsd(dailyUsd)} daily budget (config.usage.budgets.dailyUsd). em_usage {view:"insights"} shows where it went.`
+      );
+    }
+  }
+  return out;
+}
+
+// src/usage/ingest.ts
+init_esm_shims();
+import { createHash as createHash4 } from "crypto";
+import { closeSync, existsSync as existsSync3, openSync, readdirSync, readSync, statSync as statSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { basename, dirname as dirname2, join as join4, resolve as resolve3, sep } from "path";
+
+// src/usage/transcript.ts
+init_esm_shims();
+var NON_TEXT_PART_CHARS = 6400;
+var DENIAL_RE = /^\s*PreToolUse:|hook error|\bdenied\b/i;
+function isObj(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function str(v) {
+  return typeof v === "string" && v.length ? v : null;
+}
+function num3(v) {
+  return typeof v === "number" && Number.isFinite(v) ? v : 0;
+}
+function numOrNull(v) {
+  return typeof v === "number" && Number.isFinite(v) ? v : null;
+}
+function tsOf(e) {
+  const t = e.timestamp;
+  if (typeof t === "string") {
+    const ms = Date.parse(t);
+    if (Number.isFinite(ms) && ms > 0) return ms;
+    return void 0;
+  }
+  if (typeof t === "number" && Number.isFinite(t) && t > 0) return t < 1e12 ? t * 1e3 : t;
+  return void 0;
+}
+function resultChars(content) {
+  if (typeof content === "string") return content.length;
+  if (Array.isArray(content)) {
+    let n = 0;
+    for (const part of content) {
+      if (!isObj(part)) {
+        n += safeJsonLength(part);
+        continue;
+      }
+      const kind = str(part.type);
+      if (kind === "text" || typeof part.text === "string") n += str(part.text)?.length ?? 0;
+      else if (kind === "image" || kind === "document" || kind === "tool_reference")
+        n += NON_TEXT_PART_CHARS;
+      else n += safeJsonLength(part);
+    }
+    return n;
+  }
+  if (content === void 0 || content === null) return 0;
+  return safeJsonLength(content);
+}
+function resultText(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    const parts = [];
+    for (const part of content)
+      if (isObj(part) && typeof part.text === "string") parts.push(part.text);
+    return parts.join("\n");
+  }
+  return "";
+}
+function safeJsonLength(v) {
+  try {
+    return JSON.stringify(v)?.length ?? 0;
+  } catch {
+    return 0;
+  }
+}
+function parseTranscriptLines(lines, ctx) {
+  const calls = /* @__PURE__ */ new Map();
+  const toolUses = /* @__PURE__ */ new Map();
+  const contextEvents = [];
+  let lastTs;
+  let prevTs;
+  const fallbackTs = typeof ctx.fallbackTs === "number" && Number.isFinite(ctx.fallbackTs) && ctx.fallbackTs > 0 ? ctx.fallbackTs : Date.now();
+  let denied = 0;
+  for (const raw of lines) {
+    const line2 = raw.trim();
+    if (!line2) continue;
+    let e;
+    try {
+      e = JSON.parse(line2);
+    } catch {
+      continue;
+    }
+    if (!isObj(e)) continue;
+    const type = str(e.type);
+    if (!type) continue;
+    const sessionId = str(e.sessionId) ?? ctx.sessionId;
+    const agentId = str(e.agentId);
+    const sidechain = e.isSidechain === true ? 1 : 0;
+    const real = tsOf(e);
+    const ts = real ?? prevTs ?? fallbackTs;
+    prevTs = ts;
+    if (real !== void 0) lastTs = lastTs === void 0 ? real : Math.max(lastTs, real);
+    if (type === "assistant") {
+      const msg = isObj(e.message) ? e.message : void 0;
+      if (!msg) continue;
+      const messageId = str(msg.id);
+      const requestId = str(e.requestId) ?? messageId;
+      if (Array.isArray(msg.content)) {
+        for (const block of msg.content) {
+          if (!isObj(block) || block.type !== "tool_use") continue;
+          const id = str(block.id);
+          if (!id) continue;
+          const prev2 = toolUses.get(id);
+          toolUses.set(id, {
+            tool_use_id: id,
+            session_id: prev2?.session_id ?? sessionId,
+            agent_id: prev2?.agent_id ?? agentId,
+            ts: prev2?.ts ?? ts,
+            tool: str(block.name) ?? prev2?.tool ?? "",
+            input_chars: block.input === void 0 ? 0 : safeJsonLength(block.input),
+            result_chars: prev2?.result_chars ?? null,
+            is_error: prev2?.is_error ?? 0,
+            request_id: requestId ?? prev2?.request_id ?? null
+          });
+        }
+      }
+      const usage = isObj(msg.usage) ? msg.usage : void 0;
+      if (!usage || !messageId || !requestId) continue;
+      const model = str(msg.model) ?? "unknown";
+      const cc = isObj(usage.cache_creation) ? usage.cache_creation : void 0;
+      const create5m = cc ? num3(cc.ephemeral_5m_input_tokens) : num3(usage.cache_creation_input_tokens);
+      const create1h = cc ? num3(cc.ephemeral_1h_input_tokens) : 0;
+      const details = isObj(usage.output_tokens_details) ? usage.output_tokens_details : void 0;
+      const server = isObj(usage.server_tool_use) ? usage.server_tool_use : void 0;
+      const key = `${requestId}\0${messageId}`;
+      const prev = calls.get(key);
+      calls.set(key, {
+        request_id: requestId,
+        message_id: messageId,
+        session_id: prev?.session_id ?? sessionId,
+        agent_id: agentId ?? prev?.agent_id ?? null,
+        sidechain: prev?.sidechain || sidechain,
+        ts: prev?.ts ?? ts,
+        model,
+        input_tokens: num3(usage.input_tokens),
+        output_tokens: num3(usage.output_tokens),
+        cache_create_5m: create5m,
+        cache_create_1h: create1h,
+        cache_read: num3(usage.cache_read_input_tokens),
+        thinking_tokens: details ? num3(details.thinking_tokens) : 0,
+        web_searches: server ? num3(server.web_search_requests) : 0,
+        web_fetches: server ? num3(server.web_fetch_requests) : 0,
+        service_tier: str(usage.service_tier),
+        speed: str(usage.speed),
+        stop_reason: str(msg.stop_reason) ?? prev?.stop_reason ?? null,
+        prompt_id: str(e.promptId) ?? prev?.prompt_id ?? null,
+        git_branch: str(e.gitBranch) ?? prev?.git_branch ?? null,
+        cwd: str(e.cwd) ?? prev?.cwd ?? null,
+        effort: str(e.effort) ?? prev?.effort ?? null,
+        version: str(e.version) ?? prev?.version ?? null,
+        entrypoint: str(e.entrypoint) ?? prev?.entrypoint ?? null
+      });
+      continue;
+    }
+    if (type === "user") {
+      const msg = isObj(e.message) ? e.message : void 0;
+      if (!msg || !Array.isArray(msg.content)) continue;
+      for (const block of msg.content) {
+        if (!isObj(block) || block.type !== "tool_result") continue;
+        const id = str(block.tool_use_id);
+        if (!id) continue;
+        const prev = toolUses.get(id);
+        let isError = prev?.is_error ?? 0;
+        if (block.is_error === true) {
+          if (DENIAL_RE.test(resultText(block.content))) denied += 1;
+          else isError = 1;
+        }
+        toolUses.set(id, {
+          tool_use_id: id,
+          session_id: prev?.session_id ?? sessionId,
+          agent_id: prev?.agent_id ?? agentId,
+          ts: prev?.ts ?? ts,
+          tool: prev?.tool ?? "",
+          input_chars: prev?.input_chars ?? 0,
+          result_chars: resultChars(block.content),
+          is_error: isError,
+          request_id: prev?.request_id ?? null
+        });
+      }
+      continue;
+    }
+    if (type === "system") {
+      const subtype = str(e.subtype);
+      if (subtype === "compact_boundary") {
+        const meta3 = isObj(e.compactMetadata) ? e.compactMetadata : void 0;
+        contextEvents.push({
+          session_id: sessionId,
+          ts,
+          kind: "compact",
+          trigger: meta3 ? str(meta3.trigger) : null,
+          pre_tokens: meta3 ? numOrNull(meta3.preTokens) : null,
+          post_tokens: meta3 ? numOrNull(meta3.postTokens) : null
+        });
+      } else if (subtype === "local_command") {
+        const run = isObj(e.commandRun) ? e.commandRun : void 0;
+        if (run && str(run.command) === "clear") {
+          contextEvents.push({
+            session_id: sessionId,
+            ts,
+            kind: "clear",
+            trigger: "manual",
+            pre_tokens: null,
+            post_tokens: null
+          });
+        }
+      }
+    }
+  }
+  const out = {
+    calls: [...calls.values()],
+    toolUses: [...toolUses.values()],
+    contextEvents,
+    denied
+  };
+  if (lastTs !== void 0) out.lastTs = lastTs;
+  return out;
+}
+
+// src/usage/ingest.ts
+var ZERO = { calls: 0, toolUses: 0, contextEvents: 0 };
+var HEAD_BYTES = 512;
+var SNAPSHOT_MAX_AGE_MS = 30 * 24 * 60 * 6e4;
+var SNAPSHOT_KEEP_PER_SESSION = 500;
+var SESSION_ID_RE = /^[A-Za-z0-9_-]{1,80}$/;
+function isValidSessionId(id) {
+  return SESSION_ID_RE.test(id);
+}
+function claudeDir() {
+  return process.env.EMINIAR_CLAUDE_DIR || join4(homedir2(), ".claude");
+}
+function insideDir(path2, dir) {
+  const d = resolve3(dir);
+  const p = resolve3(path2);
+  return p === d || p.startsWith(d.endsWith(sep) ? d : d + sep);
+}
+function isTranscriptFile(path2) {
+  if (!path2.endsWith(".jsonl")) return false;
+  try {
+    return statSync2(path2).isFile();
+  } catch {
+    return false;
+  }
+}
+function transcriptSlug(root) {
+  return root.replace(/[^A-Za-z0-9]/g, "-");
+}
+function transcriptDirFor(root) {
+  return join4(claudeDir(), "projects", transcriptSlug(root));
+}
+function usageEnabled(ctx) {
+  return ctx.config.usage.enabled !== false;
+}
+function priceCalls(calls, overrides) {
+  return calls.map((c) => {
+    const price2 = resolvePrice(c.model, overrides);
+    if (!price2) return { ...c, cost_usd: null, priced: 0 };
+    return { ...c, cost_usd: costOfCall(c, price2).total, priced: 1 };
+  });
+}
+function readCompleteLines(path2, offset, size) {
+  const length = size - offset;
+  if (length <= 0) return { lines: [], nextOffset: offset };
+  const buf = Buffer.alloc(length);
+  const fd = openSync(path2, "r");
+  let read = 0;
+  try {
+    while (read < length) {
+      const n = readSync(fd, buf, read, length - read, offset + read);
+      if (n <= 0) break;
+      read += n;
+    }
+  } finally {
+    closeSync(fd);
+  }
+  const end = buf.lastIndexOf(10, read - 1);
+  if (end < 0) return { lines: [], nextOffset: offset };
+  const text = buf.toString("utf8", 0, end + 1);
+  return { lines: text.split("\n"), nextOffset: offset + end + 1 };
+}
+function headHash(path2, length) {
+  if (length <= 0) return null;
+  const buf = Buffer.alloc(length);
+  let read = 0;
+  const fd = openSync(path2, "r");
+  try {
+    while (read < length) {
+      const n = readSync(fd, buf, read, length - read, read);
+      if (n <= 0) break;
+      read += n;
+    }
+  } finally {
+    closeSync(fd);
+  }
+  return createHash4("sha1").update(buf.subarray(0, read)).digest("hex");
+}
+function byteAt(path2, pos) {
+  if (pos < 0) return void 0;
+  const buf = Buffer.alloc(1);
+  const fd = openSync(path2, "r");
+  try {
+    return readSync(fd, buf, 0, 1, pos) === 1 ? buf[0] : void 0;
+  } finally {
+    closeSync(fd);
+  }
+}
+function sessionIdFromName(path2) {
+  const dir = dirname2(path2);
+  if (basename(dir) === "subagents") return basename(dirname2(dir));
+  const name = basename(path2, ".jsonl");
+  return name.startsWith("agent-") ? void 0 : name;
+}
+function contextEventExists(db, e) {
+  return db.contextEvents({ sessionId: e.session_id, since: e.ts, until: e.ts + 1 }).some((x) => x.kind === e.kind);
+}
+function resumeOffset(path2, prev, size, mtime) {
+  if (!prev || prev.offset <= 0) return 0;
+  if (size < prev.offset) return 0;
+  if (prev.head_hash) {
+    const want = Math.min(HEAD_BYTES, prev.size);
+    try {
+      if (headHash(path2, want) !== prev.head_hash) return 0;
+    } catch {
+      return 0;
+    }
+  }
+  if (prev.mtime !== mtime) {
+    try {
+      if (byteAt(path2, prev.offset - 1) !== 10) return 0;
+    } catch {
+      return 0;
+    }
+  }
+  return prev.offset;
+}
+function ingestTranscript(db, path2, opts = {}) {
+  if (!path2.endsWith(".jsonl")) return ZERO;
+  let size;
+  let mtime;
+  try {
+    const st = statSync2(path2);
+    if (!st.isFile()) return ZERO;
+    size = st.size;
+    mtime = Math.floor(st.mtimeMs);
+  } catch {
+    return ZERO;
+  }
+  const prev = db.transcriptFileGet(path2);
+  const offset = resumeOffset(path2, prev, size, mtime);
+  const sessionHint = opts.sessionId ?? prev?.session_id ?? sessionIdFromName(path2);
+  if (offset === size) {
+    if (!prev || prev.size !== size || prev.mtime !== mtime || sessionHint && !prev.session_id)
+      db.transcriptFileSet({
+        path: path2,
+        session_id: sessionHint ?? null,
+        offset,
+        size,
+        mtime,
+        head_hash: prev?.size === size ? prev.head_hash ?? null : fingerprint(path2, size),
+        ingested_at: Date.now()
+      });
+    return ZERO;
+  }
+  const { lines, nextOffset } = readCompleteLines(path2, offset, size);
+  const parsed = parseTranscriptLines(lines, {
+    sessionId: sessionHint ?? "unknown",
+    path: path2,
+    fallbackTs: mtime
+  });
+  const calls = priceCalls(parsed.calls, opts.overrides);
+  const counts = { calls: 0, toolUses: 0, contextEvents: 0 };
+  const sessionSeen = parsed.calls[0]?.session_id ?? parsed.toolUses[0]?.session_id;
+  const head = fingerprint(path2, size);
+  db.transaction(() => {
+    counts.calls = db.apiCallsUpsert(calls);
+    counts.toolUses = db.toolUsesUpsert(parsed.toolUses);
+    for (const e of parsed.contextEvents) {
+      if (contextEventExists(db, e)) continue;
+      db.contextEventInsert(e);
+      counts.contextEvents++;
+    }
+    db.transcriptFileSet({
+      path: path2,
+      session_id: sessionHint ?? sessionSeen ?? null,
+      offset: nextOffset,
+      size,
+      mtime,
+      head_hash: head,
+      ingested_at: Date.now()
+    });
+  });
+  return counts;
+}
+function fingerprint(path2, size) {
+  try {
+    return headHash(path2, Math.min(HEAD_BYTES, size));
+  } catch {
+    return null;
+  }
+}
+function pruneSnapshots(db) {
+  try {
+    db.statuslineSnapshotsPrune({
+      olderThan: Date.now() - SNAPSHOT_MAX_AGE_MS,
+      keepPerSession: SNAPSHOT_KEEP_PER_SESSION
+    });
+  } catch {
+  }
+}
+function add(a, b) {
+  return {
+    calls: a.calls + b.calls,
+    toolUses: a.toolUses + b.toolUses,
+    contextEvents: a.contextEvents + b.contextEvents
+  };
+}
+function listJsonl(dir) {
+  try {
+    return readdirSync(dir).filter((f) => f.endsWith(".jsonl")).map((f) => join4(dir, f));
+  } catch {
+    return [];
+  }
+}
+function firstEntrySessionId(path2) {
+  try {
+    const { lines } = readCompleteLines(path2, 0, Math.min(statSync2(path2).size, 64 * 1024));
+    for (const line2 of lines) {
+      if (!line2.trim()) continue;
+      const e = JSON.parse(line2);
+      return typeof e.sessionId === "string" ? e.sessionId : void 0;
+    }
+  } catch {
+  }
+  return void 0;
+}
+function sidechainFilesFor(db, dir, sessionId) {
+  if (!isValidSessionId(sessionId)) return [];
+  const inside = (p) => insideDir(p, dir) && p.endsWith(".jsonl");
+  const out = listJsonl(join4(dir, sessionId, "subagents")).filter(inside);
+  for (const path2 of listJsonl(dir)) {
+    if (!inside(path2) || !basename(path2).startsWith("agent-")) continue;
+    const known = db.transcriptFileGet(path2)?.session_id;
+    let owner = known ?? void 0;
+    if (!owner) {
+      owner = firstEntrySessionId(path2);
+      if (owner) {
+        db.transcriptFileSet({
+          path: path2,
+          session_id: owner,
+          offset: 0,
+          size: 0,
+          mtime: 0,
+          ingested_at: Date.now()
+        });
+      }
+    }
+    if (owner === sessionId) out.push(path2);
+  }
+  return out;
+}
+function ingestSession(db, root, sessionId, transcriptPath, opts = {}) {
+  if (!isValidSessionId(sessionId)) return ZERO;
+  let main2;
+  const trusted = transcriptPath ?? db.sessionGet(sessionId)?.transcript_path ?? void 0;
+  if (trusted) {
+    if (!isTranscriptFile(trusted)) return ZERO;
+    main2 = resolve3(trusted);
+  } else {
+    const built = resolve3(transcriptDirFor(root), `${sessionId}.jsonl`);
+    if (!insideDir(built, claudeDir())) return ZERO;
+    main2 = built;
+  }
+  let total = ingestTranscript(db, main2, { sessionId, overrides: opts.overrides });
+  for (const path2 of sidechainFilesFor(db, dirname2(main2), sessionId)) {
+    total = add(total, ingestTranscript(db, path2, { sessionId, overrides: opts.overrides }));
+  }
+  pruneSnapshots(db);
+  return total;
+}
+
 // src/hooks/capture.ts
 var INDEXED = /* @__PURE__ */ new Set([
   "decision",
@@ -28876,30 +30797,51 @@ function open3(input2) {
   });
   return { db, root: ctx.root, sessionId };
 }
+function ingestUsage(db, input2, sessionId) {
+  try {
+    const ctx = getContext(input2.cwd);
+    if (!usageEnabled(ctx)) return;
+    const overrides = ctx.config.usage.pricing;
+    ingestSession(db, ctx.root, sessionId, input2.transcript_path, { overrides });
+    if (input2.agent_transcript_path)
+      ingestTranscript(db, input2.agent_transcript_path, { sessionId, overrides });
+  } catch {
+  }
+}
 var userPromptSubmit = async (input2) => {
   if (!input2.prompt?.trim()) return void 0;
   const { db, sessionId } = open3(input2);
   db.sessionUpsert({ id: sessionId, last_prompt: clip(input2.prompt, 600) });
   persist(db, sessionId, withPriority(sessionId, classifyPrompt(input2.prompt)));
-  const { recall } = getContext(input2.cwd).config;
-  if (!recall.onPrompt) return void 0;
+  const ctx = getContext(input2.cwd);
+  const { recall } = ctx.config;
+  const parts = [];
+  if (recall.onPrompt) {
+    try {
+      const r = await recallForText(db, input2.prompt, {
+        maxMemories: recall.maxMemories,
+        maxDocs: recall.maxDocs,
+        sessionId,
+        repeatAfter: recall.repeatAfter,
+        trace: true,
+        path: "prompt"
+      });
+      recordShown(db, sessionId, r.keys, { path: "prompt", trace: r.trace });
+      if (r.text) parts.push(r.text);
+    } catch {
+    }
+  }
   try {
-    const r = await recallForText(db, input2.prompt, {
-      maxMemories: recall.maxMemories,
-      maxDocs: recall.maxDocs,
-      sessionId,
-      repeatAfter: recall.repeatAfter,
-      trace: true,
-      path: "prompt"
-    });
-    recordShown(db, sessionId, r.keys, { path: "prompt", trace: r.trace });
-    if (!r.text) return void 0;
-    return {
-      hookSpecificOutput: { hookEventName: "UserPromptSubmit", additionalContext: r.text }
-    };
+    if (usageEnabled(ctx)) parts.push(...budgetWarnings(db, ctx, sessionId));
   } catch {
-    return void 0;
   }
+  if (!parts.length) return void 0;
+  return {
+    hookSpecificOutput: {
+      hookEventName: "UserPromptSubmit",
+      additionalContext: parts.join("\n\n")
+    }
+  };
 };
 function detectLoop(db, sessionId, key, summary) {
   const recent = db.eventsRecent(30, ["tool_call"]).filter((e) => e.session_id === sessionId);
@@ -28965,23 +30907,26 @@ var postToolUseFailure = async (input2) => {
 var subagentStop = (input2) => {
   const { db, sessionId } = open3(input2);
   const msg = input2.last_assistant_message ?? "";
-  if (!msg.trim()) return void 0;
-  persist(
-    db,
-    sessionId,
-    withPriority(sessionId, [
-      ev("agent_findings", {
-        agent: input2.agent_type ?? input2.agent_id,
-        text: clip(msg.replace(/\s+/g, " "), 1e3)
-      })
-    ])
-  );
+  if (msg.trim()) {
+    persist(
+      db,
+      sessionId,
+      withPriority(sessionId, [
+        ev("agent_findings", {
+          agent: input2.agent_type ?? input2.agent_id,
+          text: clip(msg.replace(/\s+/g, " "), 1e3)
+        })
+      ])
+    );
+  }
+  ingestUsage(db, input2, sessionId);
   return void 0;
 };
 var stop = (input2) => {
   const { db, sessionId } = open3(input2);
   const msg = input2.last_assistant_message ?? "";
   persist(db, sessionId, withPriority(sessionId, classifyAssistant(msg)));
+  ingestUsage(db, input2, sessionId);
   return void 0;
 };
 var sessionEnd = (input2) => {
@@ -28990,6 +30935,7 @@ var sessionEnd = (input2) => {
   db.eventInsert({
     ...withPriority(sessionId, [ev("session_start", { ended: input2.reason ?? "unknown" })])[0]
   });
+  ingestUsage(db, input2, sessionId);
   globalDb();
   return void 0;
 };
@@ -29118,19 +31064,20 @@ var preCompact = (input2) => {
 
 // src/hooks/routing.ts
 init_esm_shims();
-import { realpathSync as realpathSync4, statSync as statSync4 } from "fs";
-import { extname as extname2, join as join11, relative as relative4, resolve as resolve3 } from "path";
+import { realpathSync as realpathSync4, statSync as statSync5 } from "fs";
+import { homedir as homedir5 } from "os";
+import { extname as extname2, join as join12, relative as relative4, resolve as resolve4 } from "path";
 
 // src/docs/manifest.ts
 init_esm_shims();
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync } from "fs";
-import { dirname as dirname2, join as join4 } from "path";
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync } from "fs";
+import { dirname as dirname3, join as join5 } from "path";
 var NAME_RE = /^[a-z0-9][a-z0-9._-]{0,63}$/;
 function isValidName(name) {
   return NAME_RE.test(name);
 }
 function manifestPathAt(root, rel = ".eminiar/docs.json") {
-  return join4(root, rel);
+  return join5(root, rel);
 }
 function manifestPath(ctx) {
   return manifestPathAt(ctx.root, ctx.config.docs.manifest);
@@ -29158,7 +31105,7 @@ function normalize(raw) {
   return { version: 1, sources: out };
 }
 function readManifestAt(file3) {
-  if (!existsSync3(file3)) return empty();
+  if (!existsSync4(file3)) return empty();
   try {
     return normalize(JSON.parse(readFileSync3(file3, "utf8")));
   } catch {
@@ -29171,9 +31118,9 @@ function readManifest(ctx) {
 
 // src/permissions/settings.ts
 init_esm_shims();
-import { existsSync as existsSync4, readFileSync as readFileSync4, realpathSync as realpathSync3, statSync as statSync2 } from "fs";
-import { homedir as homedir2 } from "os";
-import { join as join5 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync4, realpathSync as realpathSync3, statSync as statSync3 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join6 } from "path";
 
 // src/permissions/rules.ts
 init_esm_shims();
@@ -29210,7 +31157,7 @@ init_esm_shims();
 
 // src/permissions/settings.ts
 function readRules(file3) {
-  if (!existsSync4(file3)) return {};
+  if (!existsSync5(file3)) return {};
   try {
     const s = JSON.parse(readFileSync4(file3, "utf8"));
     return s.permissions ?? {};
@@ -29220,7 +31167,7 @@ function readRules(file3) {
 }
 function stamp(file3) {
   try {
-    return statSync2(file3).mtimeMs;
+    return statSync3(file3).mtimeMs;
   } catch {
     return -1;
   }
@@ -29228,9 +31175,9 @@ function stamp(file3) {
 var cache2 = /* @__PURE__ */ new Map();
 function loadPermissionRules(root, extraDeny = []) {
   const files = [
-    join5(homedir2(), ".claude", "settings.json"),
-    join5(root, ".claude", "settings.json"),
-    join5(root, ".claude", "settings.local.json")
+    join6(homedir3(), ".claude", "settings.json"),
+    join6(root, ".claude", "settings.json"),
+    join6(root, ".claude", "settings.local.json")
   ];
   const key = `${root}\0${extraDeny.join("\0")}`;
   const stamps = files.map(stamp);
@@ -29268,8 +31215,8 @@ function checkReadPath(rules, abs) {
 
 // src/session/brief.ts
 init_esm_shims();
-import { existsSync as existsSync6, readFileSync as readFileSync6 } from "fs";
-import { join as join7 } from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync6 } from "fs";
+import { join as join8 } from "path";
 
 // src/memory/frontmatter.ts
 init_esm_shims();
@@ -29303,15 +31250,15 @@ function parseMemoryFile(text) {
 init_esm_shims();
 var import_fast_glob2 = __toESM(require_out4(), 1);
 import {
-  existsSync as existsSync5,
+  existsSync as existsSync6,
   mkdirSync as mkdirSync3,
   readFileSync as readFileSync5,
   renameSync,
-  statSync as statSync3,
+  statSync as statSync4,
   unlinkSync,
   writeFileSync as writeFileSync2
 } from "fs";
-import { dirname as dirname3, join as join6, relative as relative3, sep } from "path";
+import { dirname as dirname4, join as join7, relative as relative3, sep as sep2 } from "path";
 
 // src/storage/types.ts
 init_esm_shims();
@@ -29323,7 +31270,7 @@ function memoriesRel(ctx) {
   return ctx.config.memories.dir.replace(/^\.\//, "").replace(/\/+$/, "");
 }
 function memoriesDir(ctx) {
-  return join6(ctx.root, memoriesRel(ctx));
+  return join7(ctx.root, memoriesRel(ctx));
 }
 
 // src/session/brief.ts
@@ -29366,8 +31313,8 @@ function historyLine(db) {
   return `${parts.join("; ")}. em_history {action:"file", path} before editing, {action:"risk"} before committing.`;
 }
 function overviewParagraph(ctx) {
-  const file3 = join7(memoriesDir(ctx), "onboarding", "overview.md");
-  if (!existsSync6(file3)) return void 0;
+  const file3 = join8(memoriesDir(ctx), "onboarding", "overview.md");
+  if (!existsSync7(file3)) return void 0;
   try {
     const body = parseMemoryFile(readFileSync6(file3, "utf8")).body.trim();
     const para = body.split(/\n\s*\n/).map(
@@ -29416,12 +31363,32 @@ function fitBudget(lines, budget) {
   return out.length > budget ? `${out.slice(0, budget - 1)}\u2026` : out;
 }
 
+// src/session/routing-stats.ts
+init_esm_shims();
+var ROUTING_CATEGORY = "routing";
+function recordRouting(db, sessionId, e) {
+  db.eventInsert({
+    sessionId,
+    category: ROUTING_CATEGORY,
+    priority: 4,
+    tool: e.tool,
+    payload: {
+      tool: e.tool,
+      decision: e.decision,
+      ...e.target ? { target: e.target } : {},
+      ...e.rule ? { rule: e.rule } : {},
+      ...e.why ? { why: e.why } : {},
+      ...e.head ? { head: e.head.slice(0, 120) } : {}
+    }
+  });
+}
+
 // src/session/server-alive.ts
 init_esm_shims();
-import { existsSync as existsSync7, mkdirSync as mkdirSync4, readdirSync, rmSync, writeFileSync as writeFileSync3 } from "fs";
-import { join as join8 } from "path";
+import { existsSync as existsSync8, mkdirSync as mkdirSync4, readdirSync as readdirSync2, rmSync, writeFileSync as writeFileSync3 } from "fs";
+import { join as join9 } from "path";
 function markersDir(ctx) {
-  return join8(projectDir(ctx.id), "servers");
+  return join9(projectDir(ctx.id), "servers");
 }
 function processAlive(pid) {
   try {
@@ -29433,13 +31400,13 @@ function processAlive(pid) {
 }
 function liveServers(ctx) {
   const dir = markersDir(ctx);
-  if (!existsSync7(dir)) return [];
+  if (!existsSync8(dir)) return [];
   const live2 = [];
-  for (const name of readdirSync(dir)) {
+  for (const name of readdirSync2(dir)) {
     const pid = Number(name);
     if (!Number.isInteger(pid) || pid <= 0) continue;
     if (processAlive(pid)) live2.push(pid);
-    else rmSync(join8(dir, name), { force: true });
+    else rmSync(join9(dir, name), { force: true });
   }
   return live2;
 }
@@ -29450,29 +31417,29 @@ function serverAlive(ctx) {
 // src/hooks/coexist.ts
 init_esm_shims();
 import { readFileSync as readFileSync8 } from "fs";
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 
 // src/install/claude-config.ts
 init_esm_shims();
 import {
   copyFileSync,
-  existsSync as existsSync8,
+  existsSync as existsSync9,
   mkdirSync as mkdirSync5,
-  readdirSync as readdirSync2,
+  readdirSync as readdirSync3,
   readFileSync as readFileSync7,
   writeFileSync as writeFileSync4
 } from "fs";
-import { homedir as homedir3 } from "os";
-import { dirname as dirname4, join as join9 } from "path";
-var claudeDir = () => process.env.CLAUDE_CONFIG_DIR || join9(homedir3(), ".claude");
-var pluginsDir = () => join9(claudeDir(), "plugins");
+import { homedir as homedir4 } from "os";
+import { dirname as dirname5, join as join10 } from "path";
+var claudeDir2 = () => process.env.CLAUDE_CONFIG_DIR || join10(homedir4(), ".claude");
+var pluginsDir = () => join10(claudeDir2(), "plugins");
 
 // src/hooks/coexist.ts
 var cached2;
 function contextModeInstalled() {
   if (cached2 !== void 0) return cached2;
   try {
-    const reg = JSON.parse(readFileSync8(join10(pluginsDir(), "installed_plugins.json"), "utf8"));
+    const reg = JSON.parse(readFileSync8(join11(pluginsDir(), "installed_plugins.json"), "utf8"));
     cached2 = Object.keys(reg.plugins ?? {}).some((id) => id.startsWith("context-mode@"));
   } catch {
     cached2 = false;
@@ -29568,7 +31535,7 @@ function historyCall(cmd) {
 }
 function docsSources(root) {
   try {
-    return readManifestAt(join11(root, ".eminiar", "docs.json")).sources;
+    return readManifestAt(join12(root, ".eminiar", "docs.json")).sources;
   } catch {
     return [];
   }
@@ -29609,40 +31576,213 @@ var BIG_TEXT_EXT = /* @__PURE__ */ new Set([
 function withoutHeredocs(cmd) {
   return cmd.replace(/<<-?\s*(['"]?)(\w+)\1[^\n]*\n[\s\S]*?\n\s*\2\s*(?=\n|$)/g, "<<$2");
 }
+function splitUnquoted(s, sep3) {
+  const out = [];
+  let cur = "";
+  let quote2;
+  for (let i = 0; i < s.length; i++) {
+    const ch = s[i];
+    if (quote2) {
+      cur += ch;
+      if (ch === quote2 && s[i - 1] !== "\\") quote2 = void 0;
+      continue;
+    }
+    if (ch === "'" || ch === '"') {
+      quote2 = ch;
+      cur += ch;
+      continue;
+    }
+    const n = sep3(s, i);
+    if (n) {
+      out.push(cur);
+      cur = "";
+      i += n - 1;
+      continue;
+    }
+    cur += ch;
+  }
+  out.push(cur);
+  return out.map((p) => p.trim()).filter(Boolean);
+}
+function commandSegments(cmd) {
+  return splitUnquoted(cmd, (s, i) => {
+    const ch = s[i];
+    if (ch === ";" || ch === "\n") return 1;
+    if ((ch === "&" || ch === "|") && s[i + 1] === ch) return 2;
+    return 0;
+  });
+}
+function pipeStages(segment) {
+  return splitUnquoted(segment, (s, i) => s[i] === "|" && s[i + 1] !== "|" ? 1 : 0);
+}
+function headLines(stage) {
+  const m = /(?:^|\s)(?:-n\s*=?\s*|-)(\d+)(?=\s|$)|--lines[= ](\d+)/.exec(stage);
+  return m ? Number(m[1] ?? m[2]) : 10;
+}
+var BOUNDED_LINES = 400;
+function bounds(stage) {
+  if (/^\s*wc\b/.test(stage)) return true;
+  if (!/^\s*(head|tail)\b/.test(stage) || /(^|\s)-c\b|--bytes\b/.test(stage)) return false;
+  return headLines(stage) <= BOUNDED_LINES;
+}
+var MUTATING = /^\s*(?:(?:sudo|env|[A-Z_][A-Z0-9_]*=\S*)\s+)*(git\s+(add|commit|checkout|switch|push|pull|fetch|merge|rebase|stash|reset|restore|cherry-pick|revert|tag|init|clone|worktree|mv|rm|am|apply|submodule)|npm\s+(install|i|ci|uninstall|un|link|publish|version|update|up|dedupe)|pnpm\s+(install|i|add|remove|rm|update|up|link)|yarn\s+(add|remove|install|upgrade)|pip3?\s+(install|uninstall)|cargo\s+(add|install)|brew\s+(install|uninstall|upgrade)|gh\s+(pr|issue|release|repo)\s+(create|edit|merge|close|comment|delete|ready)|rm|mv|cp|mkdir|rmdir|touch|chmod|chown|ln|sed\s+(?:-\S+\s+)*-i|tee)\b/;
+var WRITES_FILE = /(?:^|\s|\d)>{1,2}\s*(?!&)(?!\/dev\/null)\S/;
+function mutates(segment) {
+  return MUTATING.test(segment) || WRITES_FILE.test(segment);
+}
+var READ_LIMIT = 200 * 1024;
+var BIG_TEXT_LIMIT = 20 * 1024;
+var GREP_VALUE_FLAGS = /* @__PURE__ */ new Set([
+  "-e",
+  "-f",
+  "-m",
+  "-A",
+  "-B",
+  "-C",
+  "-d",
+  "-g",
+  "-t",
+  "-T",
+  "--regexp",
+  "--file",
+  "--max-count",
+  "--after-context",
+  "--before-context",
+  "--context",
+  "--include",
+  "--exclude",
+  "--glob",
+  "--type"
+]);
+function fileOperands(stage, cwd) {
+  const tokens = stage.trim().split(/\s+/);
+  const cmd = tokens[0];
+  const isGrep = /^(grep|egrep|fgrep|rg)$/.test(cmd);
+  const files = [];
+  let patternGiven = !isGrep;
+  for (let i = 1; i < tokens.length; i++) {
+    const t = tokens[i];
+    if (t === "--") {
+      files.push(...tokens.slice(i + 1));
+      break;
+    }
+    if (t.startsWith("-") && t.length > 1) {
+      if (/^-[ef]$|^--(regexp|file)$/.test(t)) patternGiven = true;
+      if (GREP_VALUE_FLAGS.has(t)) i++;
+      continue;
+    }
+    if (!patternGiven) {
+      patternGiven = true;
+      continue;
+    }
+    files.push(t);
+  }
+  if (!files.length) return void 0;
+  const out = [];
+  for (let f of files) {
+    if (/[*?[\]{}$`\\]/.test(f)) return void 0;
+    f = f.replace(/^['"]|['"]$/g, "");
+    if (f.startsWith("~/")) f = join12(homedir5(), f.slice(2));
+    out.push(resolve4(cwd, f));
+  }
+  return out;
+}
+function stageBytes(stage, cwd) {
+  const files = fileOperands(stage, cwd);
+  if (!files) return void 0;
+  let total = 0;
+  for (const f of files) {
+    try {
+      const st = statSync5(f);
+      if (st.isDirectory()) return void 0;
+      if (BIG_TEXT_EXT.has(extname2(f).toLowerCase()) && st.size > BIG_TEXT_LIMIT)
+        return READ_LIMIT + st.size;
+      total += st.size;
+    } catch {
+    }
+  }
+  return total;
+}
+function sedRangeLines(stage) {
+  const m = /^\s*sed\s+(?:-\S+\s+)*-n\s+['"]?(\d+),(\d+)p['"]?/.exec(stage);
+  return m ? Number(m[2]) - Number(m[1]) + 1 : void 0;
+}
+function firstStageBound(first, cwd) {
+  if (/^\s*(head|tail)\s/.test(first)) return bounds(first) || void 0;
+  const sed = sedRangeLines(first);
+  if (sed !== void 0) return sed <= BOUNDED_LINES || void 0;
+  if (/^\s*du\s+-[a-zA-Z]*s/.test(first)) return true;
+  if (/^\s*git\s+log\b/.test(first) && ONE_COMMIT.test(first)) return true;
+  if (/^\s*(grep|egrep|fgrep|rg)\s/.test(first) && /(^|\s)-[a-zA-Z]*[lLcq][a-zA-Z]*(?=\s|$)|--(files-with-matches|files-without-match|count|quiet)\b/.test(
+    first
+  ))
+    return true;
+  if (/^\s*(cat|grep|egrep|fgrep|rg)\s/.test(first)) {
+    const bytes = stageBytes(first, cwd);
+    if (bytes === void 0) return void 0;
+    if (bytes <= READ_LIMIT) return true;
+    return { rule: "big-read", text: `reads about ${Math.round(bytes / 1024)} KB` };
+  }
+  return void 0;
+}
+function heavySegment(segment, cwd) {
+  if (TINY_BASH.test(segment)) return void 0;
+  const stages = pipeStages(segment);
+  const first = stages[0];
+  if (!first) return void 0;
+  if (stages.length > 1 && bounds(stages[stages.length - 1])) return void 0;
+  const bound = firstStageBound(first, cwd);
+  if (bound === true) return void 0;
+  if (bound) return bound;
+  if (HEAVY_BASH.test(first)) return { rule: "heavy", text: "usually prints a lot" };
+  if (stages.slice(1).some((s) => /^\s*(grep|rg|sort|uniq|jq|less)\b/.test(s)))
+    return { rule: "pipe", text: "streams an unbounded output through a filter" };
+  return void 0;
+}
+function headOf(segment, n = 60) {
+  const one = segment.replace(/\s+/g, " ").trim();
+  return one.length > n ? `${one.slice(0, n - 1)}\u2026` : one;
+}
+function bashSuggestion(raw, cwd) {
+  const cmd = withoutHeredocs(raw);
+  if (!cmd.trim()) return void 0;
+  const segments = commandSegments(cmd);
+  if (segments.some(mutates)) return void 0;
+  const history = historyCall(cmd);
+  if (history) {
+    return {
+      tool: "em_history",
+      rule: "history",
+      reason: `the git history is already classified (commit kinds, fixes traced to the change that caused them, risk per file); em_history ${history} answers this without the raw log`
+    };
+  }
+  for (const segment of segments) {
+    const heavy = heavySegment(segment, cwd);
+    if (!heavy) continue;
+    return {
+      tool: "em_execute",
+      rule: heavy.rule,
+      reason: `\`${headOf(segment)}\` ${heavy.text}; em_execute {language:"shell", code, intent} keeps the output out of context and returns only matching sections`
+    };
+  }
+  return void 0;
+}
 function suggest(toolName, input2, root, extra = {}) {
   switch (toolName) {
-    case "Bash": {
-      const cmd = withoutHeredocs(String(input2.command ?? ""));
-      if (!cmd || TINY_BASH.test(cmd)) return void 0;
-      if (/^\s*cat\b[^|\n]*>/.test(cmd) && !cmd.includes("|")) return void 0;
-      const history = historyCall(cmd);
-      if (history) {
-        return {
-          tool: "em_history",
-          reason: `the git history is already classified (commit kinds, fixes traced to the change that caused them, risk per file); em_history ${history} answers this without the raw log`
-        };
-      }
-      if (/^\s*git\s+log\b/.test(cmd) && ONE_COMMIT.test(cmd) && !cmd.includes("|"))
-        return void 0;
-      if (HEAVY_BASH.test(cmd) || /\|\s*(head|tail|grep|wc|sort|uniq|jq|less)\b/.test(cmd)) {
-        return {
-          tool: "em_execute",
-          reason: `this command is likely to print a lot; em_execute {language:"shell", code, intent} keeps the output out of context and returns only matching sections`
-        };
-      }
-      return void 0;
-    }
+    case "Bash":
+      return bashSuggestion(String(input2.command ?? ""), extra.cwd ?? root);
     case "Read": {
       const fp = String(input2.file_path ?? "");
       if (!fp) return void 0;
       try {
-        const abs = resolve3(root, fp);
-        const st = statSync4(abs);
+        const abs = resolve4(root, fp);
+        const st = statSync5(abs);
         const ext = extname2(fp).toLowerCase();
         if (st.size > 200 * 1024 || BIG_TEXT_EXT.has(ext) && st.size > 20 * 1024) {
           if (!checkReadPath(loadPermissionRules(root), abs).allowed) return void 0;
           return {
             tool: "em_execute_file",
+            rule: "big-read",
             reason: `${fp} is ${Math.round(st.size / 1024)} KB; em_execute_file {path, code} processes it in the sandbox so only what you print enters context`
           };
         }
@@ -29655,6 +31795,7 @@ function suggest(toolName, input2, root, extra = {}) {
       if (extra.symbol) {
         return {
           tool: "em_symbols",
+          rule: "symbol",
           annotateOnly: !content,
           reason: `the graph indexes "${extra.symbol}": em_symbols {name_path:"${extra.symbol}", mode:"references"} lists its uses, {include_body:true} its definition; em_search {queries:["${extra.symbol}"], source:"code"} finds the code by symbol`
         };
@@ -29662,6 +31803,7 @@ function suggest(toolName, input2, root, extra = {}) {
       if (content) {
         return {
           tool: "em_execute",
+          rule: "content-grep",
           reason: `content-mode grep can be large; em_execute with rg and an intent returns only matching sections (em_search {queries, mode:"regex"} scans the indexed files with context)`
         };
       }
@@ -29698,7 +31840,7 @@ function suggest(toolName, input2, root, extra = {}) {
 }
 function projectRel(ctx, fp) {
   if (!fp) return void 0;
-  let abs = resolve3(ctx.root, fp);
+  let abs = resolve4(ctx.root, fp);
   try {
     abs = realpathSync4(abs);
   } catch {
@@ -29830,9 +31972,16 @@ var preToolUse = async (input2) => {
   const graph = graphContext(ctx, input2);
   const hint = joinHints(graph, memo2);
   const symbol2 = input2.tool_name === "Grep" && graph ? literalOf(String(input2.tool_input.pattern ?? "")) : void 0;
-  const s = suggest(input2.tool_name, input2.tool_input, ctx.root, { symbol: symbol2 });
-  if (!s) return withContext(void 0, hint);
-  if (s.annotateOnly) return withContext(annotate(s), hint);
+  const s = suggest(input2.tool_name, input2.tool_input, ctx.root, { symbol: symbol2, cwd: input2.cwd });
+  const record2 = routingRecorder(ctx, input2, s);
+  if (!s) {
+    record2("allow");
+    return withContext(void 0, hint);
+  }
+  if (s.annotateOnly) {
+    record2("annotate", "annotate-only");
+    return withContext(annotate(s), hint);
+  }
   if (mode === "enforce") {
     if (s.prefixPrompt) {
       const prompt = String(input2.tool_input.prompt ?? "");
@@ -29853,6 +32002,7 @@ var preToolUse = async (input2) => {
         "info",
         `enforce \u2192 annotate for ${input2.tool_name}: no eminiar MCP server running for ${ctx.root}`
       );
+      record2("annotate", "no-server");
       return withContext(
         annotate(
           s,
@@ -29861,6 +32011,8 @@ var preToolUse = async (input2) => {
         hint
       );
     }
+    record2("deny");
+    hookLog("info", `deny ${input2.tool_name} \u2192 ${s.tool} [${s.rule ?? "?"}]: ${callHead(input2)}`);
     return {
       hookSpecificOutput: {
         hookEventName: "PreToolUse",
@@ -29869,9 +32021,35 @@ var preToolUse = async (input2) => {
       }
     };
   }
+  record2("annotate", "mode");
   const extra = s.prefixPrompt ? joinHints((await briefFor(ctx, String(input2.tool_input.prompt ?? ""))).trim(), hint) : hint;
   return withContext(annotate(s), extra);
 };
+var ROUTED_TOOLS = /* @__PURE__ */ new Set(["Bash", "Read", "Grep", "WebFetch", "WebSearch"]);
+function callHead(input2) {
+  const t = input2.tool_input ?? {};
+  const v = t.command ?? t.file_path ?? t.pattern ?? t.url ?? t.query ?? "";
+  return headOf(String(v), 120);
+}
+function routingRecorder(ctx, input2, s) {
+  const tool = input2.tool_name ?? "";
+  const sessionId = input2.session_id;
+  if (!sessionId || !ROUTED_TOOLS.has(tool)) return () => {
+  };
+  return (decision, why) => {
+    try {
+      recordRouting(getStorage(ctx, { vectors: false }), sessionId, {
+        tool,
+        decision,
+        target: s?.tool,
+        rule: s?.rule,
+        why,
+        head: callHead(input2)
+      });
+    } catch {
+    }
+  };
+}
 async function briefFor(ctx, task) {
   const parts = [];
   try {
@@ -29909,15 +32087,15 @@ function annotate(s, note = "") {
 
 // src/hooks/session-start.ts
 init_esm_shims();
-import { appendFileSync as appendFileSync2, existsSync as existsSync9, readdirSync as readdirSync3 } from "fs";
-import { join as join13 } from "path";
+import { appendFileSync as appendFileSync2, existsSync as existsSync10, readdirSync as readdirSync4 } from "fs";
+import { join as join14 } from "path";
 
 // src/session/current.ts
 init_esm_shims();
-import { readFileSync as readFileSync9, statSync as statSync5, writeFileSync as writeFileSync5 } from "fs";
-import { join as join12 } from "path";
+import { readFileSync as readFileSync9, statSync as statSync6, writeFileSync as writeFileSync5 } from "fs";
+import { join as join13 } from "path";
 function file2(ctx) {
-  return join12(projectDir(ctx.id), "current-session");
+  return join13(projectDir(ctx.id), "current-session");
 }
 function setCurrentSession(ctx, sessionId) {
   writeFileSync5(file2(ctx), sessionId);
@@ -29944,7 +32122,7 @@ function routingGuidance(mode) {
     '- em_docs: the documentation knowledge base (local docs plus the libraries, services and APIs the project uses); {action:"discover"} / {action:"add", pick:"recommended"} build it, {action:"sync"} refreshes it.',
     '- em_search {queries, sort:"timeline"}: everything indexed plus session memory.',
     "- em_remember {content, kind, name?, status?}: memories are markdown under .eminiar/memories (survive compaction, shareable via git); em_memory {action: list|read|edit|rename|delete|status} manages them.",
-    '- em_architecture {aspects?}: the project map (folders, entry points, routes, hotspots, decisions) in one call; em_symbols {name_path | mode:"overview", file} for a symbol or a file outline; em_graph_impact {node} before a refactor; em_graph_changes for what the current diff reaches; em_graph_query {pattern | preset} to walk the graph; em_index_status for coverage. em_stats shows savings.',
+    '- em_architecture {aspects?}: the project map (folders, entry points, routes, hotspots, decisions) in one call; em_symbols {name_path | mode:"overview", file} for a symbol or a file outline; em_graph_impact {node} before a refactor; em_graph_changes for what the current diff reaches; em_graph_query {pattern | preset} to walk the graph; em_index_status for coverage. em_stats shows savings; em_usage {view} shows model calls, cost, cache and insights.',
     "- em_history {action: overview | file {path} | risk | commit {sha} | branch {name} | symbol {name_path} | search {query}}: the git history classified (feat/fix/refactor\u2026), branches vs base, and each fix traced back to the commit that caused it \u2014 ask it before editing a file or committing instead of running git log/blame/show (those are routed to it); commit messages are searchable via em_search (source git).",
     '- A Grep for an identifier the graph knows is routed to em_symbols {name_path, mode:"references"} / em_search {queries, source:"code"}: symbol-level answers instead of raw matches.',
     "Plain Bash/Read/Grep remain right for short fixed output and files you are about to edit."
@@ -29978,6 +32156,7 @@ export EMINIAR_PROJECT_ROOT=${JSON.stringify(ctx.root)}
     } catch {
     }
   }
+  if (input2.source === "compact" || input2.source === "resume") ingestUsage(db, input2, sessionId);
   const parts = [];
   if (input2.source === "compact" || input2.source === "resume") {
     const snap = db.snapshotLatestUnconsumed(sessionId);
@@ -30001,8 +32180,15 @@ ${guide}`);
   } catch {
   }
   try {
-    const onboarding = join13(memoriesDir(ctx), "onboarding");
-    const onboarded = existsSync9(onboarding) && readdirSync3(onboarding).some((f) => f.endsWith(".md"));
+    if (ctx.config.usage.enabled) {
+      const { line: line2 } = usageBrief(db, ctx, { sessionId });
+      if (line2) parts.push(`eminiar usage \u2014 ${line2}`);
+    }
+  } catch {
+  }
+  try {
+    const onboarding = join14(memoriesDir(ctx), "onboarding");
+    const onboarded = existsSync10(onboarding) && readdirSync4(onboarding).some((f) => f.endsWith(".md"));
     if (!onboarded)
       parts.push(
         "No onboarding memories yet: run /eminiar:em-onboard once so future sessions start with the project's structure, build and test commands."
@@ -30014,7 +32200,7 @@ ${guide}`);
   } catch {
   }
   try {
-    if (existsSync9(join13(ctx.root, ".git")) && !db.metaGet("history_files"))
+    if (existsSync10(join14(ctx.root, ".git")) && !db.metaGet("history_files"))
       parts.push(
         'Git history is not classified yet: em_history {action:"overview"} builds it (the server also does this in the background shortly after start); bug-prone files are flagged before you read or edit them once it exists.'
       );