@contextstream/mcp-server 0.4.36 → 0.4.38

package/dist/index.js

@@ -1,9 +1,496 @@
 #!/usr/bin/env node
+var __create = Object.create;
 var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/ignore/index.js
+var require_ignore = __commonJS({
+  "node_modules/ignore/index.js"(exports, module) {
+    function makeArray(subject) {
+      return Array.isArray(subject) ? subject : [subject];
+    }
+    var UNDEFINED = void 0;
+    var EMPTY = "";
+    var SPACE = " ";
+    var ESCAPE = "\\";
+    var REGEX_TEST_BLANK_LINE = /^\s+$/;
+    var REGEX_INVALID_TRAILING_BACKSLASH = /(?:[^\\]|^)\\$/;
+    var REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\!/;
+    var REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\#/;
+    var REGEX_SPLITALL_CRLF = /\r?\n/g;
+    var REGEX_TEST_INVALID_PATH = /^\.{0,2}\/|^\.{1,2}$/;
+    var REGEX_TEST_TRAILING_SLASH = /\/$/;
+    var SLASH = "/";
+    var TMP_KEY_IGNORE = "node-ignore";
+    if (typeof Symbol !== "undefined") {
+      TMP_KEY_IGNORE = /* @__PURE__ */ Symbol.for("node-ignore");
+    }
+    var KEY_IGNORE = TMP_KEY_IGNORE;
+    var define = (object, key, value) => {
+      Object.defineProperty(object, key, { value });
+      return value;
+    };
+    var REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g;
+    var RETURN_FALSE = () => false;
+    var sanitizeRange = (range) => range.replace(
+      REGEX_REGEXP_RANGE,
+      (match, from, to) => from.charCodeAt(0) <= to.charCodeAt(0) ? match : EMPTY
+    );
+    var cleanRangeBackSlash = (slashes) => {
+      const { length } = slashes;
+      return slashes.slice(0, length - length % 2);
+    };
+    var REPLACERS = [
+      [
+        // Remove BOM
+        // TODO:
+        // Other similar zero-width characters?
+        /^\uFEFF/,
+        () => EMPTY
+      ],
+      // > Trailing spaces are ignored unless they are quoted with backslash ("\")
+      [
+        // (a\ ) -> (a )
+        // (a  ) -> (a)
+        // (a ) -> (a)
+        // (a \ ) -> (a  )
+        /((?:\\\\)*?)(\\?\s+)$/,
+        (_, m1, m2) => m1 + (m2.indexOf("\\") === 0 ? SPACE : EMPTY)
+      ],
+      // Replace (\ ) with ' '
+      // (\ ) -> ' '
+      // (\\ ) -> '\\ '
+      // (\\\ ) -> '\\ '
+      [
+        /(\\+?)\s/g,
+        (_, m1) => {
+          const { length } = m1;
+          return m1.slice(0, length - length % 2) + SPACE;
+        }
+      ],
+      // Escape metacharacters
+      // which is written down by users but means special for regular expressions.
+      // > There are 12 characters with special meanings:
+      // > - the backslash \,
+      // > - the caret ^,
+      // > - the dollar sign $,
+      // > - the period or dot .,
+      // > - the vertical bar or pipe symbol |,
+      // > - the question mark ?,
+      // > - the asterisk or star *,
+      // > - the plus sign +,
+      // > - the opening parenthesis (,
+      // > - the closing parenthesis ),
+      // > - and the opening square bracket [,
+      // > - the opening curly brace {,
+      // > These special characters are often called "metacharacters".
+      [
+        /[\\$.|*+(){^]/g,
+        (match) => `\\${match}`
+      ],
+      [
+        // > a question mark (?) matches a single character
+        /(?!\\)\?/g,
+        () => "[^/]"
+      ],
+      // leading slash
+      [
+        // > A leading slash matches the beginning of the pathname.
+        // > For example, "/*.c" matches "cat-file.c" but not "mozilla-sha1/sha1.c".
+        // A leading slash matches the beginning of the pathname
+        /^\//,
+        () => "^"
+      ],
+      // replace special metacharacter slash after the leading slash
+      [
+        /\//g,
+        () => "\\/"
+      ],
+      [
+        // > A leading "**" followed by a slash means match in all directories.
+        // > For example, "**/foo" matches file or directory "foo" anywhere,
+        // > the same as pattern "foo".
+        // > "**/foo/bar" matches file or directory "bar" anywhere that is directly
+        // >   under directory "foo".
+        // Notice that the '*'s have been replaced as '\\*'
+        /^\^*\\\*\\\*\\\//,
+        // '**/foo' <-> 'foo'
+        () => "^(?:.*\\/)?"
+      ],
+      // starting
+      [
+        // there will be no leading '/'
+        //   (which has been replaced by section "leading slash")
+        // If starts with '**', adding a '^' to the regular expression also works
+        /^(?=[^^])/,
+        function startingReplacer() {
+          return !/\/(?!$)/.test(this) ? "(?:^|\\/)" : "^";
+        }
+      ],
+      // two globstars
+      [
+        // Use lookahead assertions so that we could match more than one `'/**'`
+        /\\\/\\\*\\\*(?=\\\/|$)/g,
+        // Zero, one or several directories
+        // should not use '*', or it will be replaced by the next replacer
+        // Check if it is not the last `'/**'`
+        (_, index, str) => index + 6 < str.length ? "(?:\\/[^\\/]+)*" : "\\/.+"
+      ],
+      // normal intermediate wildcards
+      [
+        // Never replace escaped '*'
+        // ignore rule '\*' will match the path '*'
+        // 'abc.*/' -> go
+        // 'abc.*'  -> skip this rule,
+        //    coz trailing single wildcard will be handed by [trailing wildcard]
+        /(^|[^\\]+)(\\\*)+(?=.+)/g,
+        // '*.js' matches '.js'
+        // '*.js' doesn't match 'abc'
+        (_, p1, p2) => {
+          const unescaped = p2.replace(/\\\*/g, "[^\\/]*");
+          return p1 + unescaped;
+        }
+      ],
+      [
+        // unescape, revert step 3 except for back slash
+        // For example, if a user escape a '\\*',
+        // after step 3, the result will be '\\\\\\*'
+        /\\\\\\(?=[$.|*+(){^])/g,
+        () => ESCAPE
+      ],
+      [
+        // '\\\\' -> '\\'
+        /\\\\/g,
+        () => ESCAPE
+      ],
+      [
+        // > The range notation, e.g. [a-zA-Z],
+        // > can be used to match one of the characters in a range.
+        // `\` is escaped by step 3
+        /(\\)?\[([^\]/]*?)(\\*)($|\])/g,
+        (match, leadEscape, range, endEscape, close) => leadEscape === ESCAPE ? `\\[${range}${cleanRangeBackSlash(endEscape)}${close}` : close === "]" ? endEscape.length % 2 === 0 ? `[${sanitizeRange(range)}${endEscape}]` : "[]" : "[]"
+      ],
+      // ending
+      [
+        // 'js' will not match 'js.'
+        // 'ab' will not match 'abc'
+        /(?:[^*])$/,
+        // WTF!
+        // https://git-scm.com/docs/gitignore
+        // changes in [2.22.1](https://git-scm.com/docs/gitignore/2.22.1)
+        // which re-fixes #24, #38
+        // > If there is a separator at the end of the pattern then the pattern
+        // > will only match directories, otherwise the pattern can match both
+        // > files and directories.
+        // 'js*' will not match 'a.js'
+        // 'js/' will not match 'a.js'
+        // 'js' will match 'a.js' and 'a.js/'
+        (match) => /\/$/.test(match) ? `${match}$` : `${match}(?=$|\\/$)`
+      ]
+    ];
+    var REGEX_REPLACE_TRAILING_WILDCARD = /(^|\\\/)?\\\*$/;
+    var MODE_IGNORE = "regex";
+    var MODE_CHECK_IGNORE = "checkRegex";
+    var UNDERSCORE = "_";
+    var TRAILING_WILD_CARD_REPLACERS = {
+      [MODE_IGNORE](_, p1) {
+        const prefix = p1 ? `${p1}[^/]+` : "[^/]*";
+        return `${prefix}(?=$|\\/$)`;
+      },
+      [MODE_CHECK_IGNORE](_, p1) {
+        const prefix = p1 ? `${p1}[^/]*` : "[^/]*";
+        return `${prefix}(?=$|\\/$)`;
+      }
+    };
+    var makeRegexPrefix = (pattern) => REPLACERS.reduce(
+      (prev, [matcher, replacer]) => prev.replace(matcher, replacer.bind(pattern)),
+      pattern
+    );
+    var isString = (subject) => typeof subject === "string";
+    var checkPattern = (pattern) => pattern && isString(pattern) && !REGEX_TEST_BLANK_LINE.test(pattern) && !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern) && pattern.indexOf("#") !== 0;
+    var splitPattern = (pattern) => pattern.split(REGEX_SPLITALL_CRLF).filter(Boolean);
+    var IgnoreRule = class {
+      constructor(pattern, mark, body, ignoreCase, negative, prefix) {
+        this.pattern = pattern;
+        this.mark = mark;
+        this.negative = negative;
+        define(this, "body", body);
+        define(this, "ignoreCase", ignoreCase);
+        define(this, "regexPrefix", prefix);
+      }
+      get regex() {
+        const key = UNDERSCORE + MODE_IGNORE;
+        if (this[key]) {
+          return this[key];
+        }
+        return this._make(MODE_IGNORE, key);
+      }
+      get checkRegex() {
+        const key = UNDERSCORE + MODE_CHECK_IGNORE;
+        if (this[key]) {
+          return this[key];
+        }
+        return this._make(MODE_CHECK_IGNORE, key);
+      }
+      _make(mode, key) {
+        const str = this.regexPrefix.replace(
+          REGEX_REPLACE_TRAILING_WILDCARD,
+          // It does not need to bind pattern
+          TRAILING_WILD_CARD_REPLACERS[mode]
+        );
+        const regex = this.ignoreCase ? new RegExp(str, "i") : new RegExp(str);
+        return define(this, key, regex);
+      }
+    };
+    var createRule = ({
+      pattern,
+      mark
+    }, ignoreCase) => {
+      let negative = false;
+      let body = pattern;
+      if (body.indexOf("!") === 0) {
+        negative = true;
+        body = body.substr(1);
+      }
+      body = body.replace(REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION, "!").replace(REGEX_REPLACE_LEADING_EXCAPED_HASH, "#");
+      const regexPrefix = makeRegexPrefix(body);
+      return new IgnoreRule(
+        pattern,
+        mark,
+        body,
+        ignoreCase,
+        negative,
+        regexPrefix
+      );
+    };
+    var RuleManager = class {
+      constructor(ignoreCase) {
+        this._ignoreCase = ignoreCase;
+        this._rules = [];
+      }
+      _add(pattern) {
+        if (pattern && pattern[KEY_IGNORE]) {
+          this._rules = this._rules.concat(pattern._rules._rules);
+          this._added = true;
+          return;
+        }
+        if (isString(pattern)) {
+          pattern = {
+            pattern
+          };
+        }
+        if (checkPattern(pattern.pattern)) {
+          const rule = createRule(pattern, this._ignoreCase);
+          this._added = true;
+          this._rules.push(rule);
+        }
+      }
+      // @param {Array<string> | string | Ignore} pattern
+      add(pattern) {
+        this._added = false;
+        makeArray(
+          isString(pattern) ? splitPattern(pattern) : pattern
+        ).forEach(this._add, this);
+        return this._added;
+      }
+      // Test one single path without recursively checking parent directories
+      //
+      // - checkUnignored `boolean` whether should check if the path is unignored,
+      //   setting `checkUnignored` to `false` could reduce additional
+      //   path matching.
+      // - check `string` either `MODE_IGNORE` or `MODE_CHECK_IGNORE`
+      // @returns {TestResult} true if a file is ignored
+      test(path9, checkUnignored, mode) {
+        let ignored = false;
+        let unignored = false;
+        let matchedRule;
+        this._rules.forEach((rule) => {
+          const { negative } = rule;
+          if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
+            return;
+          }
+          const matched = rule[mode].test(path9);
+          if (!matched) {
+            return;
+          }
+          ignored = !negative;
+          unignored = negative;
+          matchedRule = negative ? UNDEFINED : rule;
+        });
+        const ret = {
+          ignored,
+          unignored
+        };
+        if (matchedRule) {
+          ret.rule = matchedRule;
+        }
+        return ret;
+      }
+    };
+    var throwError = (message, Ctor) => {
+      throw new Ctor(message);
+    };
+    var checkPath = (path9, originalPath, doThrow) => {
+      if (!isString(path9)) {
+        return doThrow(
+          `path must be a string, but got \`${originalPath}\``,
+          TypeError
+        );
+      }
+      if (!path9) {
+        return doThrow(`path must not be empty`, TypeError);
+      }
+      if (checkPath.isNotRelative(path9)) {
+        const r = "`path.relative()`d";
+        return doThrow(
+          `path should be a ${r} string, but got "${originalPath}"`,
+          RangeError
+        );
+      }
+      return true;
+    };
+    var isNotRelative = (path9) => REGEX_TEST_INVALID_PATH.test(path9);
+    checkPath.isNotRelative = isNotRelative;
+    checkPath.convert = (p) => p;
+    var Ignore2 = class {
+      constructor({
+        ignorecase = true,
+        ignoreCase = ignorecase,
+        allowRelativePaths = false
+      } = {}) {
+        define(this, KEY_IGNORE, true);
+        this._rules = new RuleManager(ignoreCase);
+        this._strictPathCheck = !allowRelativePaths;
+        this._initCache();
+      }
+      _initCache() {
+        this._ignoreCache = /* @__PURE__ */ Object.create(null);
+        this._testCache = /* @__PURE__ */ Object.create(null);
+      }
+      add(pattern) {
+        if (this._rules.add(pattern)) {
+          this._initCache();
+        }
+        return this;
+      }
+      // legacy
+      addPattern(pattern) {
+        return this.add(pattern);
+      }
+      // @returns {TestResult}
+      _test(originalPath, cache, checkUnignored, slices) {
+        const path9 = originalPath && checkPath.convert(originalPath);
+        checkPath(
+          path9,
+          originalPath,
+          this._strictPathCheck ? throwError : RETURN_FALSE
+        );
+        return this._t(path9, cache, checkUnignored, slices);
+      }
+      checkIgnore(path9) {
+        if (!REGEX_TEST_TRAILING_SLASH.test(path9)) {
+          return this.test(path9);
+        }
+        const slices = path9.split(SLASH).filter(Boolean);
+        slices.pop();
+        if (slices.length) {
+          const parent = this._t(
+            slices.join(SLASH) + SLASH,
+            this._testCache,
+            true,
+            slices
+          );
+          if (parent.ignored) {
+            return parent;
+          }
+        }
+        return this._rules.test(path9, false, MODE_CHECK_IGNORE);
+      }
+      _t(path9, cache, checkUnignored, slices) {
+        if (path9 in cache) {
+          return cache[path9];
+        }
+        if (!slices) {
+          slices = path9.split(SLASH).filter(Boolean);
+        }
+        slices.pop();
+        if (!slices.length) {
+          return cache[path9] = this._rules.test(path9, checkUnignored, MODE_IGNORE);
+        }
+        const parent = this._t(
+          slices.join(SLASH) + SLASH,
+          cache,
+          checkUnignored,
+          slices
+        );
+        return cache[path9] = parent.ignored ? parent : this._rules.test(path9, checkUnignored, MODE_IGNORE);
+      }
+      ignores(path9) {
+        return this._test(path9, this._ignoreCache, false).ignored;
+      }
+      createFilter() {
+        return (path9) => !this.ignores(path9);
+      }
+      filter(paths) {
+        return makeArray(paths).filter(this.createFilter());
+      }
+      // @returns {TestResult}
+      test(path9) {
+        return this._test(path9, this._testCache, true);
+      }
+    };
+    var factory = (options) => new Ignore2(options);
+    var isPathValid = (path9) => checkPath(path9 && checkPath.convert(path9), path9, RETURN_FALSE);
+    var setupWindows = () => {
+      const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
+      checkPath.convert = makePosix;
+      const REGEX_TEST_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
+      checkPath.isNotRelative = (path9) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path9) || isNotRelative(path9);
+    };
+    if (
+      // Detect `process` so that it can run in browsers.
+      typeof process !== "undefined" && process.platform === "win32"
+    ) {
+      setupWindows();
+    }
+    module.exports = factory;
+    factory.default = factory;
+    module.exports.isPathValid = isPathValid;
+    define(module.exports, /* @__PURE__ */ Symbol.for("setupWindows"), setupWindows);
+  }
+});
 
 // src/index.ts
 import { McpServer as McpServer2 } from "@modelcontextprotocol/sdk/server/mcp.js";
@@ -487,8 +974,8 @@ function getErrorMap() {
 
 // node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path8, errorMaps, issueData } = params;
-  const fullPath = [...path8, ...issueData.path || []];
+  const { data, path: path9, errorMaps, issueData } = params;
+  const fullPath = [...path9, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -604,11 +1091,11 @@ var errorUtil;
 
 // node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path8, key) {
+  constructor(parent, value, path9, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path8;
+    this._path = path9;
     this._key = key;
   }
   get path() {
@@ -4195,7 +4682,8 @@ var configSchema = external_exports.object({
   defaultProjectId: external_exports.string().uuid().optional(),
   userAgent: external_exports.string().default(`contextstream-mcp/${VERSION}`),
   allowHeaderAuth: external_exports.boolean().optional(),
-  contextPackEnabled: external_exports.boolean().default(true)
+  contextPackEnabled: external_exports.boolean().default(true),
+  showTiming: external_exports.boolean().default(false)
 });
 var MISSING_CREDENTIALS_ERROR = "Set CONTEXTSTREAM_API_KEY or CONTEXTSTREAM_JWT for authentication (or CONTEXTSTREAM_ALLOW_HEADER_AUTH=true for header-based auth).";
 function isMissingCredentialsError(err) {
@@ -4209,6 +4697,7 @@ function loadConfig() {
   const contextPackEnabled = parseBooleanEnv(
     process.env.CONTEXTSTREAM_CONTEXT_PACK ?? process.env.CONTEXTSTREAM_CONTEXT_PACK_ENABLED
   );
+  const showTiming = parseBooleanEnv(process.env.CONTEXTSTREAM_SHOW_TIMING);
   const parsed = configSchema.safeParse({
     apiUrl: process.env.CONTEXTSTREAM_API_URL,
     apiKey: process.env.CONTEXTSTREAM_API_KEY,
@@ -4217,7 +4706,8 @@ function loadConfig() {
     defaultProjectId: process.env.CONTEXTSTREAM_PROJECT_ID,
     userAgent: process.env.CONTEXTSTREAM_USER_AGENT,
     allowHeaderAuth,
-    contextPackEnabled
+    contextPackEnabled,
+    showTiming
   });
   if (!parsed.success) {
     const missing = parsed.error.errors.map((e) => e.path.join(".")).join(", ");
@@ -4233,7 +4723,7 @@ function loadConfig() {
 
 // src/client.ts
 import { randomUUID } from "node:crypto";
-import * as path3 from "node:path";
+import * as path4 from "node:path";
 
 // src/auth-context.ts
 import { AsyncLocalStorage } from "node:async_hooks";
@@ -4299,12 +4789,12 @@ var BASE_DELAY = 1e3;
 async function sleep(ms) {
   return new Promise((resolve4) => setTimeout(resolve4, ms));
 }
-async function request(config, path8, options = {}) {
+async function request(config, path9, options = {}) {
   const { apiUrl, userAgent } = config;
   const authOverride = getAuthOverride();
   const apiKey = authOverride?.apiKey ?? config.apiKey;
   const jwt = authOverride?.jwt ?? config.jwt;
-  const apiPath = path8.startsWith("/api/") ? path8 : `/api/v1${path8}`;
+  const apiPath = path9.startsWith("/api/") ? path9 : `/api/v1${path9}`;
   const url = `${apiUrl.replace(/\/$/, "")}${apiPath}`;
   const maxRetries = options.retries ?? MAX_RETRIES;
   const baseDelay = options.retryDelay ?? BASE_DELAY;
@@ -4450,9 +4940,9 @@ function extractErrorCode(payload) {
   if (typeof payload.code === "string" && payload.code.trim()) return payload.code.trim();
   return null;
 }
-function detectIntegrationProvider(path8) {
-  if (/\/github(\/|$)/i.test(path8)) return "github";
-  if (/\/slack(\/|$)/i.test(path8)) return "slack";
+function detectIntegrationProvider(path9) {
+  if (/\/github(\/|$)/i.test(path9)) return "github";
+  if (/\/slack(\/|$)/i.test(path9)) return "slack";
   return null;
 }
 function rewriteNotFoundMessage(input) {
@@ -4465,8 +4955,81 @@ function rewriteNotFoundMessage(input) {
 }
 
 // src/files.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+
+// src/ignore.ts
+var import_ignore = __toESM(require_ignore(), 1);
 import * as fs from "fs";
 import * as path from "path";
+var IGNORE_FILENAME = ".contextstream/ignore";
+var DEFAULT_IGNORE_PATTERNS = [
+  // Version control
+  ".git/",
+  ".svn/",
+  ".hg/",
+  // Package managers / dependencies
+  "node_modules/",
+  "vendor/",
+  ".pnpm/",
+  // Build outputs
+  "target/",
+  "dist/",
+  "build/",
+  "out/",
+  ".next/",
+  ".nuxt/",
+  // Python
+  "__pycache__/",
+  ".pytest_cache/",
+  ".mypy_cache/",
+  "venv/",
+  ".venv/",
+  "env/",
+  ".env/",
+  // IDE
+  ".idea/",
+  ".vscode/",
+  ".vs/",
+  // Coverage
+  "coverage/",
+  ".coverage/",
+  // Lock files
+  "package-lock.json",
+  "yarn.lock",
+  "pnpm-lock.yaml",
+  "Cargo.lock",
+  "poetry.lock",
+  "Gemfile.lock",
+  "composer.lock",
+  // OS files
+  ".DS_Store",
+  "Thumbs.db"
+];
+async function loadIgnorePatterns(projectRoot) {
+  const ig = (0, import_ignore.default)();
+  const patterns = [...DEFAULT_IGNORE_PATTERNS];
+  ig.add(DEFAULT_IGNORE_PATTERNS);
+  const ignoreFilePath = path.join(projectRoot, IGNORE_FILENAME);
+  let hasUserPatterns = false;
+  try {
+    const content = await fs.promises.readFile(ignoreFilePath, "utf-8");
+    const userPatterns = content.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
+    if (userPatterns.length > 0) {
+      ig.add(userPatterns);
+      patterns.push(...userPatterns);
+      hasUserPatterns = true;
+    }
+  } catch {
+  }
+  return {
+    ignores: (pathname) => ig.ignores(pathname),
+    patterns,
+    hasUserPatterns
+  };
+}
+
+// src/files.ts
 var CODE_EXTENSIONS = /* @__PURE__ */ new Set([
   // Rust
   "rs",
@@ -4577,31 +5140,34 @@ var MAX_FILES_PER_BATCH = 200;
 async function* readAllFilesInBatches(rootPath, options = {}) {
   const maxBatchBytes = options.maxBatchBytes ?? MAX_BATCH_BYTES;
   const largeFileThreshold = options.largeFileThreshold ?? LARGE_FILE_THRESHOLD;
-  const maxFilesPerBatch = options.maxFilesPerBatch ?? MAX_FILES_PER_BATCH;
+  const maxFilesPerBatch = options.maxFilesPerBatch ?? options.batchSize ?? MAX_FILES_PER_BATCH;
   const maxFileSize = options.maxFileSize ?? MAX_FILE_SIZE;
+  const ig = options.ignoreInstance ?? await loadIgnorePatterns(rootPath);
   let batch = [];
   let currentBatchBytes = 0;
   async function* walkDir(dir, relativePath = "") {
     let entries;
     try {
-      entries = await fs.promises.readdir(dir, { withFileTypes: true });
+      entries = await fs2.promises.readdir(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const fullPath = path.join(dir, entry.name);
-      const relPath = path.join(relativePath, entry.name);
+      const fullPath = path2.join(dir, entry.name);
+      const relPath = path2.join(relativePath, entry.name);
       if (entry.isDirectory()) {
         if (IGNORE_DIRS.has(entry.name)) continue;
+        if (ig.ignores(relPath + "/")) continue;
         yield* walkDir(fullPath, relPath);
       } else if (entry.isFile()) {
         if (IGNORE_FILES.has(entry.name)) continue;
+        if (ig.ignores(relPath)) continue;
         const ext = entry.name.split(".").pop()?.toLowerCase() ?? "";
         if (!CODE_EXTENSIONS.has(ext)) continue;
         try {
-          const stat2 = await fs.promises.stat(fullPath);
+          const stat2 = await fs2.promises.stat(fullPath);
           if (stat2.size > maxFileSize) continue;
-          const content = await fs.promises.readFile(fullPath, "utf-8");
+          const content = await fs2.promises.readFile(fullPath, "utf-8");
           yield { path: relPath, content, sizeBytes: stat2.size };
         } catch {
         }
@@ -4637,9 +5203,10 @@ async function* readAllFilesInBatches(rootPath, options = {}) {
 async function* readChangedFilesInBatches(rootPath, sinceTimestamp, options = {}) {
   const maxBatchBytes = options.maxBatchBytes ?? MAX_BATCH_BYTES;
   const largeFileThreshold = options.largeFileThreshold ?? LARGE_FILE_THRESHOLD;
-  const maxFilesPerBatch = options.maxFilesPerBatch ?? MAX_FILES_PER_BATCH;
+  const maxFilesPerBatch = options.maxFilesPerBatch ?? options.batchSize ?? MAX_FILES_PER_BATCH;
   const maxFileSize = options.maxFileSize ?? MAX_FILE_SIZE;
   const sinceMs = sinceTimestamp.getTime();
+  const ig = options.ignoreInstance ?? await loadIgnorePatterns(rootPath);
   let batch = [];
   let currentBatchBytes = 0;
   let filesScanned = 0;
@@ -4647,26 +5214,28 @@ async function* readChangedFilesInBatches(rootPath, sinceTimestamp, options = {}
   async function* walkDir(dir, relativePath = "") {
     let entries;
     try {
-      entries = await fs.promises.readdir(dir, { withFileTypes: true });
+      entries = await fs2.promises.readdir(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const fullPath = path.join(dir, entry.name);
-      const relPath = path.join(relativePath, entry.name);
+      const fullPath = path2.join(dir, entry.name);
+      const relPath = path2.join(relativePath, entry.name);
       if (entry.isDirectory()) {
         if (IGNORE_DIRS.has(entry.name)) continue;
+        if (ig.ignores(relPath + "/")) continue;
         yield* walkDir(fullPath, relPath);
       } else if (entry.isFile()) {
         if (IGNORE_FILES.has(entry.name)) continue;
+        if (ig.ignores(relPath)) continue;
         const ext = entry.name.split(".").pop()?.toLowerCase() ?? "";
         if (!CODE_EXTENSIONS.has(ext)) continue;
         try {
-          const stat2 = await fs.promises.stat(fullPath);
+          const stat2 = await fs2.promises.stat(fullPath);
           filesScanned++;
           if (stat2.mtimeMs <= sinceMs) continue;
           if (stat2.size > maxFileSize) continue;
-          const content = await fs.promises.readFile(fullPath, "utf-8");
+          const content = await fs2.promises.readFile(fullPath, "utf-8");
           filesChanged++;
           yield { path: relPath, content, sizeBytes: stat2.size };
         } catch {
@@ -4706,16 +5275,17 @@ async function* readChangedFilesInBatches(rootPath, sinceTimestamp, options = {}
 async function countIndexableFiles(rootPath, options = {}) {
   const maxFiles = options.maxFiles ?? 1;
   const maxFileSize = options.maxFileSize ?? MAX_FILE_SIZE;
+  const ig = options.ignoreInstance ?? await loadIgnorePatterns(rootPath);
   let count = 0;
   let stopped = false;
-  async function walkDir(dir) {
+  async function walkDir(dir, relativePath = "") {
     if (count >= maxFiles) {
       stopped = true;
       return;
     }
     let entries;
     try {
-      entries = await fs.promises.readdir(dir, { withFileTypes: true });
+      entries = await fs2.promises.readdir(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -4724,16 +5294,19 @@ async function countIndexableFiles(rootPath, options = {}) {
         stopped = true;
         return;
       }
-      const fullPath = path.join(dir, entry.name);
+      const fullPath = path2.join(dir, entry.name);
+      const relPath = path2.join(relativePath, entry.name);
       if (entry.isDirectory()) {
         if (IGNORE_DIRS.has(entry.name)) continue;
-        await walkDir(fullPath);
+        if (ig.ignores(relPath + "/")) continue;
+        await walkDir(fullPath, relPath);
       } else if (entry.isFile()) {
         if (IGNORE_FILES.has(entry.name)) continue;
+        if (ig.ignores(relPath)) continue;
         const ext = entry.name.split(".").pop()?.toLowerCase() ?? "";
         if (!CODE_EXTENSIONS.has(ext)) continue;
         try {
-          const stat2 = await fs.promises.stat(fullPath);
+          const stat2 = await fs2.promises.stat(fullPath);
           if (stat2.size > maxFileSize) continue;
           count++;
           if (count >= maxFiles) {
@@ -4750,16 +5323,16 @@ async function countIndexableFiles(rootPath, options = {}) {
 }
 
 // src/workspace-config.ts
-import * as fs2 from "fs";
-import * as path2 from "path";
+import * as fs3 from "fs";
+import * as path3 from "path";
 var CONFIG_DIR = ".contextstream";
 var CONFIG_FILE = "config.json";
 var GLOBAL_MAPPINGS_FILE = ".contextstream-mappings.json";
 function readLocalConfig(repoPath) {
-  const configPath = path2.join(repoPath, CONFIG_DIR, CONFIG_FILE);
+  const configPath = path3.join(repoPath, CONFIG_DIR, CONFIG_FILE);
   try {
-    if (fs2.existsSync(configPath)) {
-      const content = fs2.readFileSync(configPath, "utf-8");
+    if (fs3.existsSync(configPath)) {
+      const content = fs3.readFileSync(configPath, "utf-8");
       return JSON.parse(content);
     }
   } catch (e) {
@@ -4768,13 +5341,13 @@ function readLocalConfig(repoPath) {
   return null;
 }
 function writeLocalConfig(repoPath, config) {
-  const configDir = path2.join(repoPath, CONFIG_DIR);
-  const configPath = path2.join(configDir, CONFIG_FILE);
+  const configDir = path3.join(repoPath, CONFIG_DIR);
+  const configPath = path3.join(configDir, CONFIG_FILE);
   try {
-    if (!fs2.existsSync(configDir)) {
-      fs2.mkdirSync(configDir, { recursive: true });
+    if (!fs3.existsSync(configDir)) {
+      fs3.mkdirSync(configDir, { recursive: true });
     }
-    fs2.writeFileSync(configPath, JSON.stringify(config, null, 2));
+    fs3.writeFileSync(configPath, JSON.stringify(config, null, 2));
     return true;
   } catch (e) {
     console.error(`Failed to write config to ${configPath}:`, e);
@@ -4783,10 +5356,10 @@ function writeLocalConfig(repoPath, config) {
 }
 function readGlobalMappings() {
   const homeDir = process.env.HOME || process.env.USERPROFILE || "";
-  const mappingsPath = path2.join(homeDir, GLOBAL_MAPPINGS_FILE);
+  const mappingsPath = path3.join(homeDir, GLOBAL_MAPPINGS_FILE);
   try {
-    if (fs2.existsSync(mappingsPath)) {
-      const content = fs2.readFileSync(mappingsPath, "utf-8");
+    if (fs3.existsSync(mappingsPath)) {
+      const content = fs3.readFileSync(mappingsPath, "utf-8");
       return JSON.parse(content);
     }
   } catch (e) {
@@ -4796,9 +5369,9 @@ function readGlobalMappings() {
 }
 function writeGlobalMappings(mappings) {
   const homeDir = process.env.HOME || process.env.USERPROFILE || "";
-  const mappingsPath = path2.join(homeDir, GLOBAL_MAPPINGS_FILE);
+  const mappingsPath = path3.join(homeDir, GLOBAL_MAPPINGS_FILE);
   try {
-    fs2.writeFileSync(mappingsPath, JSON.stringify(mappings, null, 2));
+    fs3.writeFileSync(mappingsPath, JSON.stringify(mappings, null, 2));
     return true;
   } catch (e) {
     console.error(`Failed to write global mappings:`, e);
@@ -4806,20 +5379,20 @@ function writeGlobalMappings(mappings) {
   }
 }
 function addGlobalMapping(mapping) {
-  const normalizedPattern = path2.normalize(mapping.pattern);
+  const normalizedPattern = path3.normalize(mapping.pattern);
   const mappings = readGlobalMappings();
-  const filtered = mappings.filter((m) => path2.normalize(m.pattern) !== normalizedPattern);
+  const filtered = mappings.filter((m) => path3.normalize(m.pattern) !== normalizedPattern);
   filtered.push({ ...mapping, pattern: normalizedPattern });
   return writeGlobalMappings(filtered);
 }
 function findMatchingMapping(repoPath) {
   const mappings = readGlobalMappings();
-  const normalizedRepo = path2.normalize(repoPath);
+  const normalizedRepo = path3.normalize(repoPath);
   for (const mapping of mappings) {
-    const normalizedPattern = path2.normalize(mapping.pattern);
-    if (normalizedPattern.endsWith(`${path2.sep}*`)) {
+    const normalizedPattern = path3.normalize(mapping.pattern);
+    if (normalizedPattern.endsWith(`${path3.sep}*`)) {
       const parentDir = normalizedPattern.slice(0, -2);
-      if (normalizedRepo.startsWith(parentDir + path2.sep)) {
+      if (normalizedRepo.startsWith(parentDir + path3.sep)) {
         return mapping;
       }
     } else if (normalizedRepo === normalizedPattern) {
@@ -5008,6 +5581,47 @@ var INGEST_BENEFITS = [
   "Allow the AI assistant to find relevant code without manual file navigation",
   "Build a searchable knowledge base of your codebase structure"
 ];
+var PROJECT_MARKERS = [
+  ".git",
+  "package.json",
+  "Cargo.toml",
+  "pyproject.toml",
+  "go.mod",
+  "pom.xml",
+  "build.gradle",
+  "Gemfile",
+  "composer.json",
+  ".contextstream"
+];
+function isMultiProjectFolder(folderPath) {
+  try {
+    const fs8 = __require("fs");
+    const pathModule = __require("path");
+    const rootHasGit = fs8.existsSync(pathModule.join(folderPath, ".git"));
+    const entries = fs8.readdirSync(folderPath, { withFileTypes: true });
+    const subdirs = entries.filter(
+      (e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "node_modules"
+    );
+    const projectSubdirs = [];
+    for (const subdir of subdirs) {
+      const subdirPath = pathModule.join(folderPath, subdir.name);
+      for (const marker of PROJECT_MARKERS) {
+        if (fs8.existsSync(pathModule.join(subdirPath, marker))) {
+          projectSubdirs.push(subdir.name);
+          break;
+        }
+      }
+    }
+    const isMultiProject = projectSubdirs.length >= 1 && (!rootHasGit || projectSubdirs.length >= 2);
+    return {
+      isMultiProject,
+      projectCount: projectSubdirs.length,
+      projectNames: projectSubdirs
+    };
+  } catch {
+    return { isMultiProject: false, projectCount: 0, projectNames: [] };
+  }
+}
 var ContextStreamClient = class {
   constructor(config) {
     this.config = config;
@@ -5922,7 +6536,7 @@ var ContextStreamClient = class {
         context.workspace_source = resolved.source;
         context.workspace_resolved_from = resolved.source === "local_config" ? `${rootPath}/.contextstream/config.json` : "parent_folder_mapping";
       } else {
-        const folderName = rootPath ? path3.basename(rootPath).toLowerCase() : "";
+        const folderName = rootPath ? path4.basename(rootPath).toLowerCase() : "";
         try {
           const workspaces = await this.listWorkspaces({ page_size: 50 });
           if (workspaces.items && workspaces.items.length > 0) {
@@ -5978,13 +6592,13 @@ var ContextStreamClient = class {
                 name: w.name,
                 description: w.description
               }));
-              context.message = `New folder detected: "${rootPath ? path3.basename(rootPath) : "this folder"}". Please select which workspace this belongs to, or create a new one.`;
+              context.message = `New folder detected: "${rootPath ? path4.basename(rootPath) : "this folder"}". Please select which workspace this belongs to, or create a new one.`;
               context.ide_roots = ideRoots;
-              context.folder_name = rootPath ? path3.basename(rootPath) : void 0;
+              context.folder_name = rootPath ? path4.basename(rootPath) : void 0;
               return context;
             }
           } else {
-            const folderDisplayName = rootPath ? path3.basename(rootPath) || "this folder" : "this folder";
+            const folderDisplayName = rootPath ? path4.basename(rootPath) || "this folder" : "this folder";
             context.status = "requires_workspace_name";
             context.workspace_source = "none_found";
             context.ide_roots = ideRoots;
@@ -6012,7 +6626,7 @@ var ContextStreamClient = class {
       }
     }
     if (!workspaceId && !params.allow_no_workspace) {
-      const folderDisplayName = rootPath ? path3.basename(rootPath) || "this folder" : "this folder";
+      const folderDisplayName = rootPath ? path4.basename(rootPath) || "this folder" : "this folder";
       context.ide_roots = ideRoots;
       context.folder_name = folderDisplayName;
       if (rootPath) {
@@ -6043,8 +6657,26 @@ var ContextStreamClient = class {
         return context;
       }
     }
-    if (!projectId && workspaceId && rootPath && params.auto_index !== false) {
-      const projectName = path3.basename(rootPath) || "My Project";
+    let autoDetectedMultiProject = false;
+    if (!params.skip_project_creation && !projectId && rootPath) {
+      const detection = isMultiProjectFolder(rootPath);
+      if (detection.isMultiProject) {
+        autoDetectedMultiProject = true;
+        context.workspace_only_mode = true;
+        context.auto_detected_multi_project = true;
+        context.detected_projects = detection.projectNames;
+        context.project_skipped_reason = `Auto-detected ${detection.projectCount} projects in folder: ${detection.projectNames.slice(0, 5).join(", ")}${detection.projectCount > 5 ? "..." : ""}. Working at workspace level.`;
+        console.error(
+          `[ContextStream] Auto-detected multi-project folder with ${detection.projectCount} projects: ${detection.projectNames.slice(0, 5).join(", ")}`
+        );
+      }
+    }
+    if (params.skip_project_creation) {
+      context.workspace_only_mode = true;
+      context.project_skipped_reason = "skip_project_creation=true - working at workspace level for multi-project folder";
+    } else if (autoDetectedMultiProject) {
+    } else if (!projectId && workspaceId && rootPath && params.auto_index !== false) {
+      const projectName = path4.basename(rootPath) || "My Project";
       try {
         const projects = await this.listProjects({ workspace_id: workspaceId });
         const projectNameLower = projectName.toLowerCase();
@@ -6354,16 +6986,21 @@ var ContextStreamClient = class {
    * Persists the selection to .contextstream/config.json for future sessions.
    */
   async associateWorkspace(params) {
-    const { folder_path, workspace_id, workspace_name, create_parent_mapping } = params;
+    const { folder_path, workspace_id, workspace_name, create_parent_mapping, version, configured_editors, context_pack, api_url } = params;
     const saved = writeLocalConfig(folder_path, {
       workspace_id,
       workspace_name,
-      associated_at: (/* @__PURE__ */ new Date()).toISOString()
+      associated_at: (/* @__PURE__ */ new Date()).toISOString(),
+      version,
+      configured_editors,
+      context_pack,
+      api_url,
+      updated_at: (/* @__PURE__ */ new Date()).toISOString()
     });
     if (create_parent_mapping) {
-      const parentDir = path3.dirname(folder_path);
+      const parentDir = path4.dirname(folder_path);
       addGlobalMapping({
-        pattern: path3.join(parentDir, "*"),
+        pattern: path4.join(parentDir, "*"),
         workspace_id,
         workspace_name: workspace_name || "Unknown"
       });
@@ -6869,9 +7506,9 @@ var ContextStreamClient = class {
           candidateParts.push("## Relevant Code\n");
           currentChars += 18;
           const codeEntries = code.results.map((c) => {
-            const path8 = c.file_path || "file";
+            const path9 = c.file_path || "file";
             const content = c.content?.slice(0, 150) || "";
-            return { path: path8, entry: `\u2022 ${path8}: ${content}...
+            return { path: path9, entry: `\u2022 ${path9}: ${content}...
 ` };
           });
           for (const c of codeEntries) {
@@ -7029,7 +7666,10 @@ var ContextStreamClient = class {
           distill: params.distill,
           client_version: VERSION,
           rules_version: VERSION,
-          notice_inline: false
+          notice_inline: false,
+          // Session token tracking for context pressure
+          ...params.session_tokens !== void 0 && { session_tokens: params.session_tokens },
+          ...params.context_threshold !== void 0 && { context_threshold: params.context_threshold }
         }
       });
       const data = unwrapApiResponse(apiResult);
@@ -7049,7 +7689,8 @@ var ContextStreamClient = class {
         project_id: withDefaults.project_id,
         ...versionNotice2 ? { version_notice: versionNotice2 } : {},
         ...Array.isArray(data?.errors) ? { errors: data.errors } : {},
-        ...this.indexRefreshInProgress ? { index_status: "refreshing" } : {}
+        ...this.indexRefreshInProgress ? { index_status: "refreshing" } : {},
+        ...data?.context_pressure ? { context_pressure: data.context_pressure } : {}
       };
     } catch (err) {
       const message2 = err instanceof Error ? err.message : String(err);
@@ -8192,8 +8833,8 @@ W:${wsHint}
 };
 
 // src/tools.ts
-import * as fs4 from "node:fs";
-import * as path5 from "node:path";
+import * as fs5 from "node:fs";
+import * as path6 from "node:path";
 import { homedir as homedir3 } from "node:os";
 
 // src/rules-templates.ts
@@ -8417,6 +9058,39 @@ If context still feels missing, use \`session(action="recall", query="...")\` fo
 
 ---
 
+### Context Pressure & Compaction Awareness
+
+ContextStream tracks context pressure to help you stay ahead of conversation compaction:
+
+**Automatic tracking:** Token usage is tracked automatically. \`context_smart\` returns \`context_pressure\` when usage is high.
+
+**When \`context_smart\` returns \`context_pressure\` with high/critical level:**
+1. Review the \`suggested_action\` field:
+   - \`prepare_save\`: Start thinking about saving important state
+   - \`save_now\`: Immediately call \`session(action="capture", event_type="session_snapshot")\` to preserve state
+
+**PreCompact Hook (Optional):** If enabled, Claude Code will inject a reminder to save state before compaction.
+Enable with: \`generate_rules(install_hooks=true, include_pre_compact=true)\`
+
+**Before compaction happens (when warned):**
+\`\`\`
+session(action="capture", event_type="session_snapshot", title="Pre-compaction snapshot", content="{
+  \\"conversation_summary\\": \\"<summarize what we've been doing>\\",
+  \\"current_goal\\": \\"<the main task>\\",
+  \\"active_files\\": [\\"file1.ts\\", \\"file2.ts\\"],
+  \\"recent_decisions\\": [{title: \\"...\\", rationale: \\"...\\"}],
+  \\"unfinished_work\\": [{task: \\"...\\", status: \\"...\\", next_steps: \\"...\\"}]
+}")
+\`\`\`
+
+**After compaction (when context seems lost):**
+1. Call \`session_init(folder_path="...", is_post_compact=true)\` - this auto-restores the most recent snapshot
+2. Or call \`session_restore_context()\` directly to get the saved state
+3. Review the \`restored_context\` to understand prior work
+4. Acknowledge to the user what was restored and continue
+
+---
+
 ### Index Status (Auto-Managed)
 
 **Indexing is automatic.** After \`session_init\`, the project is auto-indexed in the background.
@@ -8650,12 +9324,27 @@ ContextStream search is **indexed** and returns semantic matches + context in ON
 - Before risky work: \`session(action="get_lessons", query="<topic>")\`
 - On mistakes: \`session(action="capture_lesson", title="...", trigger="...", impact="...", prevention="...")\`
 
+### Context Pressure & Compaction
+
+- If \`context_smart\` returns high/critical \`context_pressure\`: call \`session_capture_smart(...)\` to save state
+- After compaction (context lost): call \`session_init(..., is_post_compact=true)\` or \`session_restore_context()\`
+
 ### Plans & Tasks
 
 When user asks for a plan, use ContextStream (not EnterPlanMode):
 1. \`session(action="capture_plan", title="...", steps=[...])\`
 2. \`memory(action="create_task", title="...", plan_id="<id>")\`
 
+### Workspace-Only Mode (Multi-Project Folders)
+
+If working in a parent folder containing multiple projects:
+\`\`\`
+session_init(folder_path="...", skip_project_creation=true)
+\`\`\`
+
+This enables workspace-level memory and context without project-specific indexing.
+Use for monorepos or folders with multiple independent projects.
+
 Full docs: https://contextstream.io/docs/mcp/tools
 `.trim();
 var TEMPLATES = {
@@ -8937,8 +9626,8 @@ function getCoreToolsHint() {
 }
 
 // src/hooks-config.ts
-import * as fs3 from "node:fs/promises";
-import * as path4 from "node:path";
+import * as fs4 from "node:fs/promises";
+import * as path5 from "node:path";
 import { homedir as homedir2 } from "node:os";
 var PRETOOLUSE_HOOK_SCRIPT = `#!/usr/bin/env python3
 """
@@ -9108,26 +9797,102 @@ def main():
     print(json.dumps({"hookSpecificOutput": {"hookEventName": "UserPromptSubmit", "additionalContext": REMINDER}}))
     sys.exit(0)
 
+if __name__ == "__main__":
+    main()
+`;
+var PRECOMPACT_HOOK_SCRIPT = `#!/usr/bin/env python3
+"""
+ContextStream PreCompact Hook for Claude Code
+
+Runs BEFORE conversation context is compacted (manual via /compact or automatic).
+Injects a reminder for the AI to save conversation state using session_capture_smart.
+
+Input (via stdin):
+{
+  "session_id": "...",
+  "transcript_path": "/path/to/transcript.jsonl",
+  "permission_mode": "default",
+  "hook_event_name": "PreCompact",
+  "trigger": "manual" | "auto",
+  "custom_instructions": "..."
+}
+
+Output (to stdout):
+{
+  "hookSpecificOutput": {
+    "hookEventName": "PreCompact",
+    "additionalContext": "... instructions for AI ..."
+  }
+}
+"""
+
+import json
+import sys
+import os
+
+ENABLED = os.environ.get("CONTEXTSTREAM_PRECOMPACT_ENABLED", "true").lower() == "true"
+
+def main():
+    if not ENABLED:
+        sys.exit(0)
+
+    try:
+        data = json.load(sys.stdin)
+    except:
+        sys.exit(0)
+
+    trigger = data.get("trigger", "unknown")
+    custom_instructions = data.get("custom_instructions", "")
+
+    # Build context injection for the AI
+    context = f"""[CONTEXT COMPACTION IMMINENT - {trigger.upper()}]
+CRITICAL: Before context is compacted, you MUST save conversation state:
+
+1. IMMEDIATELY call: mcp__contextstream__session(action="capture", event_type="session_snapshot", title="Pre-compaction snapshot", content="<JSON with: conversation_summary, active_goals, recent_decisions, active_files, unfinished_work>")
+
+2. Include in the snapshot:
+   - conversation_summary: Brief summary of what was discussed
+   - active_goals: List of goals/tasks in progress
+   - recent_decisions: Key decisions made in this session
+   - active_files: Files currently being worked on
+   - unfinished_work: Any incomplete tasks
+
+3. After compaction, call session_init(is_post_compact=true) to restore context.
+
+{f"User instructions: {custom_instructions}" if custom_instructions else ""}
+[END COMPACTION WARNING]"""
+
+    output = {
+        "hookSpecificOutput": {
+            "hookEventName": "PreCompact",
+            "additionalContext": context
+        }
+    }
+
+    print(json.dumps(output))
+    sys.exit(0)
+
 if __name__ == "__main__":
     main()
 `;
 function getClaudeSettingsPath(scope, projectPath) {
   if (scope === "user") {
-    return path4.join(homedir2(), ".claude", "settings.json");
+    return path5.join(homedir2(), ".claude", "settings.json");
   }
   if (!projectPath) {
     throw new Error("projectPath required for project scope");
   }
-  return path4.join(projectPath, ".claude", "settings.json");
+  return path5.join(projectPath, ".claude", "settings.json");
 }
 function getHooksDir() {
-  return path4.join(homedir2(), ".claude", "hooks");
+  return path5.join(homedir2(), ".claude", "hooks");
 }
-function buildHooksConfig() {
+function buildHooksConfig(options) {
   const hooksDir = getHooksDir();
-  const preToolUsePath = path4.join(hooksDir, "contextstream-redirect.py");
-  const userPromptPath = path4.join(hooksDir, "contextstream-reminder.py");
-  return {
+  const preToolUsePath = path5.join(hooksDir, "contextstream-redirect.py");
+  const userPromptPath = path5.join(hooksDir, "contextstream-reminder.py");
+  const preCompactPath = path5.join(hooksDir, "contextstream-precompact.py");
+  const config = {
     PreToolUse: [
       {
         matcher: "Glob|Grep|Search|Task|EnterPlanMode",
@@ -9153,20 +9918,45 @@ function buildHooksConfig() {
       }
     ]
   };
+  if (options?.includePreCompact) {
+    config.PreCompact = [
+      {
+        // Match both manual (/compact) and automatic compaction
+        matcher: "*",
+        hooks: [
+          {
+            type: "command",
+            command: `python3 "${preCompactPath}"`,
+            timeout: 10
+          }
+        ]
+      }
+    ];
+  }
+  return config;
 }
-async function installHookScripts() {
+async function installHookScripts(options) {
   const hooksDir = getHooksDir();
-  await fs3.mkdir(hooksDir, { recursive: true });
-  const preToolUsePath = path4.join(hooksDir, "contextstream-redirect.py");
-  const userPromptPath = path4.join(hooksDir, "contextstream-reminder.py");
-  await fs3.writeFile(preToolUsePath, PRETOOLUSE_HOOK_SCRIPT, { mode: 493 });
-  await fs3.writeFile(userPromptPath, USER_PROMPT_HOOK_SCRIPT, { mode: 493 });
-  return { preToolUse: preToolUsePath, userPrompt: userPromptPath };
+  await fs4.mkdir(hooksDir, { recursive: true });
+  const preToolUsePath = path5.join(hooksDir, "contextstream-redirect.py");
+  const userPromptPath = path5.join(hooksDir, "contextstream-reminder.py");
+  const preCompactPath = path5.join(hooksDir, "contextstream-precompact.py");
+  await fs4.writeFile(preToolUsePath, PRETOOLUSE_HOOK_SCRIPT, { mode: 493 });
+  await fs4.writeFile(userPromptPath, USER_PROMPT_HOOK_SCRIPT, { mode: 493 });
+  const result = {
+    preToolUse: preToolUsePath,
+    userPrompt: userPromptPath
+  };
+  if (options?.includePreCompact) {
+    await fs4.writeFile(preCompactPath, PRECOMPACT_HOOK_SCRIPT, { mode: 493 });
+    result.preCompact = preCompactPath;
+  }
+  return result;
 }
 async function readClaudeSettings(scope, projectPath) {
   const settingsPath = getClaudeSettingsPath(scope, projectPath);
   try {
-    const content = await fs3.readFile(settingsPath, "utf-8");
+    const content = await fs4.readFile(settingsPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return {};
@@ -9174,9 +9964,9 @@ async function readClaudeSettings(scope, projectPath) {
 }
 async function writeClaudeSettings(settings, scope, projectPath) {
   const settingsPath = getClaudeSettingsPath(scope, projectPath);
-  const dir = path4.dirname(settingsPath);
-  await fs3.mkdir(dir, { recursive: true });
-  await fs3.writeFile(settingsPath, JSON.stringify(settings, null, 2));
+  const dir = path5.dirname(settingsPath);
+  await fs4.mkdir(dir, { recursive: true });
+  await fs4.writeFile(settingsPath, JSON.stringify(settings, null, 2));
 }
 function mergeHooksIntoSettings(existingSettings, newHooks) {
   const settings = { ...existingSettings };
@@ -9195,16 +9985,22 @@ function mergeHooksIntoSettings(existingSettings, newHooks) {
 async function installClaudeCodeHooks(options) {
   const result = { scripts: [], settings: [] };
   if (!options.dryRun) {
-    const scripts = await installHookScripts();
+    const scripts = await installHookScripts({ includePreCompact: options.includePreCompact });
     result.scripts.push(scripts.preToolUse, scripts.userPrompt);
+    if (scripts.preCompact) {
+      result.scripts.push(scripts.preCompact);
+    }
   } else {
     const hooksDir = getHooksDir();
     result.scripts.push(
-      path4.join(hooksDir, "contextstream-redirect.py"),
-      path4.join(hooksDir, "contextstream-reminder.py")
+      path5.join(hooksDir, "contextstream-redirect.py"),
+      path5.join(hooksDir, "contextstream-reminder.py")
     );
+    if (options.includePreCompact) {
+      result.scripts.push(path5.join(hooksDir, "contextstream-precompact.py"));
+    }
   }
-  const hooksConfig = buildHooksConfig();
+  const hooksConfig = buildHooksConfig({ includePreCompact: options.includePreCompact });
   if (options.scope === "user" || options.scope === "both") {
     const settingsPath = getClaudeSettingsPath("user");
     if (!options.dryRun) {
@@ -9226,12 +10022,12 @@ async function installClaudeCodeHooks(options) {
   return result;
 }
 function getIndexStatusPath() {
-  return path4.join(homedir2(), ".contextstream", "indexed-projects.json");
+  return path5.join(homedir2(), ".contextstream", "indexed-projects.json");
 }
 async function readIndexStatus() {
   const statusPath = getIndexStatusPath();
   try {
-    const content = await fs3.readFile(statusPath, "utf-8");
+    const content = await fs4.readFile(statusPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return { version: 1, projects: {} };
@@ -9239,13 +10035,13 @@ async function readIndexStatus() {
 }
 async function writeIndexStatus(status) {
   const statusPath = getIndexStatusPath();
-  const dir = path4.dirname(statusPath);
-  await fs3.mkdir(dir, { recursive: true });
-  await fs3.writeFile(statusPath, JSON.stringify(status, null, 2));
+  const dir = path5.dirname(statusPath);
+  await fs4.mkdir(dir, { recursive: true });
+  await fs4.writeFile(statusPath, JSON.stringify(status, null, 2));
 }
 async function markProjectIndexed(projectPath, options) {
   const status = await readIndexStatus();
-  const resolvedPath = path4.resolve(projectPath);
+  const resolvedPath = path5.resolve(projectPath);
   status.projects[resolvedPath] = {
     indexed_at: (/* @__PURE__ */ new Date()).toISOString(),
     project_id: options?.project_id,
@@ -9431,15 +10227,15 @@ var RULES_PROJECT_FILES = {
   cursor: ".cursorrules",
   windsurf: ".windsurfrules",
   cline: ".clinerules",
-  kilo: path5.join(".kilocode", "rules", "contextstream.md"),
-  roo: path5.join(".roo", "rules", "contextstream.md"),
+  kilo: path6.join(".kilocode", "rules", "contextstream.md"),
+  roo: path6.join(".roo", "rules", "contextstream.md"),
   aider: ".aider.conf.yml"
 };
 var RULES_GLOBAL_FILES = {
-  codex: [path5.join(homedir3(), ".codex", "AGENTS.md")],
-  windsurf: [path5.join(homedir3(), ".codeium", "windsurf", "memories", "global_rules.md")],
-  kilo: [path5.join(homedir3(), ".kilocode", "rules", "contextstream.md")],
-  roo: [path5.join(homedir3(), ".roo", "rules", "contextstream.md")]
+  codex: [path6.join(homedir3(), ".codex", "AGENTS.md")],
+  windsurf: [path6.join(homedir3(), ".codeium", "windsurf", "memories", "global_rules.md")],
+  kilo: [path6.join(homedir3(), ".kilocode", "rules", "contextstream.md")],
+  roo: [path6.join(homedir3(), ".roo", "rules", "contextstream.md")]
 };
 var rulesNoticeCache = /* @__PURE__ */ new Map();
 function compareVersions2(v1, v2) {
@@ -9492,7 +10288,7 @@ function resolveRulesCandidatePaths(folderPath, editorKey) {
     if (!folderPath) return;
     const rel = RULES_PROJECT_FILES[key];
     if (rel) {
-      candidates.add(path5.join(folderPath, rel));
+      candidates.add(path6.join(folderPath, rel));
     }
   };
   const addGlobal = (key) => {
@@ -9524,7 +10320,7 @@ function resolveFolderPath(inputPath, sessionManager) {
   const indicators = [".git", "package.json", "Cargo.toml", "pyproject.toml", ".contextstream"];
   const hasIndicator = indicators.some((entry) => {
     try {
-      return fs4.existsSync(path5.join(cwd, entry));
+      return fs5.existsSync(path6.join(cwd, entry));
     } catch {
       return false;
     }
@@ -9543,7 +10339,7 @@ function getRulesNotice(folderPath, clientName) {
     return cached.notice;
   }
   const candidates = resolveRulesCandidatePaths(folderPath, editorKey);
-  const existing = candidates.filter((filePath) => fs4.existsSync(filePath));
+  const existing = candidates.filter((filePath) => fs5.existsSync(filePath));
   if (existing.length === 0) {
     const updateCommand2 = "generate_rules()";
     const notice2 = {
@@ -9565,7 +10361,7 @@ function getRulesNotice(folderPath, clientName) {
   const versions = [];
   for (const filePath of existing) {
     try {
-      const content = fs4.readFileSync(filePath, "utf-8");
+      const content = fs5.readFileSync(filePath, "utf-8");
       const version = extractRulesVersion(content);
       if (!version) {
         filesMissingVersion.push(filePath);
@@ -9758,23 +10554,23 @@ function replaceContextStreamBlock(existing, content) {
   return { content: appended, status: "appended" };
 }
 async function upsertRuleFile(filePath, content) {
-  await fs4.promises.mkdir(path5.dirname(filePath), { recursive: true });
+  await fs5.promises.mkdir(path6.dirname(filePath), { recursive: true });
   const wrappedContent = wrapWithMarkers(content);
   let existing = "";
   try {
-    existing = await fs4.promises.readFile(filePath, "utf8");
+    existing = await fs5.promises.readFile(filePath, "utf8");
   } catch {
   }
   if (!existing) {
-    await fs4.promises.writeFile(filePath, wrappedContent + "\n", "utf8");
+    await fs5.promises.writeFile(filePath, wrappedContent + "\n", "utf8");
     return "created";
   }
   if (!existing.trim()) {
-    await fs4.promises.writeFile(filePath, wrappedContent + "\n", "utf8");
+    await fs5.promises.writeFile(filePath, wrappedContent + "\n", "utf8");
     return "updated";
   }
   const replaced = replaceContextStreamBlock(existing, content);
-  await fs4.promises.writeFile(filePath, replaced.content, "utf8");
+  await fs5.promises.writeFile(filePath, replaced.content, "utf8");
   return replaced.status;
 }
 async function writeEditorRules(options) {
@@ -9792,8 +10588,8 @@ async function writeEditorRules(options) {
       results.push({ editor, filename: "", status: "unknown editor" });
       continue;
     }
-    const filePath = path5.join(options.folderPath, rule.filename);
-    if (fs4.existsSync(filePath) && !options.overwriteExisting) {
+    const filePath = path6.join(options.folderPath, rule.filename);
+    if (fs5.existsSync(filePath) && !options.overwriteExisting) {
       results.push({ editor, filename: rule.filename, status: "skipped (exists)" });
       continue;
     }
@@ -9849,7 +10645,7 @@ async function writeGlobalRules(options) {
       continue;
     }
     for (const filePath of globalPaths) {
-      if (fs4.existsSync(filePath) && !options.overwriteExisting) {
+      if (fs5.existsSync(filePath) && !options.overwriteExisting) {
         results.push({ editor, filename: filePath, status: "skipped (exists)", scope: "global" });
         continue;
       }
@@ -9942,9 +10738,9 @@ function humanizeKey(raw) {
   const withSpaces = raw.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/_/g, " ");
   return withSpaces.toLowerCase();
 }
-function buildParamDescription(key, path8) {
+function buildParamDescription(key, path9) {
   const normalized = key in DEFAULT_PARAM_DESCRIPTIONS ? key : key.toLowerCase();
-  const parent = path8[path8.length - 1];
+  const parent = path9[path9.length - 1];
   if (parent === "target") {
     if (key === "id") return "Target identifier (module path, function id, etc.).";
     if (key === "type") return "Target type (module, file, function, type, variable).";
@@ -9975,7 +10771,7 @@ function getDescription(schema) {
   if (def?.description && def.description.trim()) return def.description;
   return void 0;
 }
-function applyParamDescriptions(schema, path8 = []) {
+function applyParamDescriptions(schema, path9 = []) {
   if (!(schema instanceof external_exports.ZodObject)) {
     return schema;
   }
@@ -9986,7 +10782,7 @@ function applyParamDescriptions(schema, path8 = []) {
     let nextField = field;
     const existingDescription = getDescription(field);
     if (field instanceof external_exports.ZodObject) {
-      const nested = applyParamDescriptions(field, [...path8, key]);
+      const nested = applyParamDescriptions(field, [...path9, key]);
       if (nested !== field) {
         nextField = nested;
         changed = true;
@@ -9998,7 +10794,7 @@ function applyParamDescriptions(schema, path8 = []) {
         changed = true;
       }
     } else {
-      nextField = nextField.describe(buildParamDescription(key, path8));
+      nextField = nextField.describe(buildParamDescription(key, path9));
       changed = true;
     }
     nextShape[key] = nextField;
@@ -10054,13 +10850,17 @@ function resolveAuthOverride(extra) {
   return { workspaceId, projectId };
 }
 var LIGHT_TOOLSET = /* @__PURE__ */ new Set([
-  // Core session tools (13)
+  // Core session tools (15)
   "session_init",
   "session_tools",
   "context_smart",
   "context_feedback",
   "session_summary",
   "session_capture",
+  "session_capture_smart",
+  // Pre-compaction state capture
+  "session_restore_context",
+  // Post-compaction context restore
   "session_capture_lesson",
   "session_get_lessons",
   "session_recall",
@@ -10100,13 +10900,17 @@ var LIGHT_TOOLSET = /* @__PURE__ */ new Set([
   "mcp_server_version"
 ]);
 var STANDARD_TOOLSET = /* @__PURE__ */ new Set([
-  // Core session tools (14)
+  // Core session tools (16)
   "session_init",
   "session_tools",
   "context_smart",
   "context_feedback",
   "session_summary",
   "session_capture",
+  "session_capture_smart",
+  // Pre-compaction state capture
+  "session_restore_context",
+  // Post-compaction context restore
   "session_capture_lesson",
   "session_get_lessons",
   "session_recall",
@@ -10557,6 +11361,7 @@ function parsePositiveInt(raw, fallback) {
 }
 var OUTPUT_FORMAT = process.env.CONTEXTSTREAM_OUTPUT_FORMAT || "compact";
 var COMPACT_OUTPUT = OUTPUT_FORMAT === "compact";
+var SHOW_TIMING = process.env.CONTEXTSTREAM_SHOW_TIMING === "true" || process.env.CONTEXTSTREAM_SHOW_TIMING === "1";
 var DEFAULT_SEARCH_LIMIT = parsePositiveInt(process.env.CONTEXTSTREAM_SEARCH_LIMIT, 3);
 var DEFAULT_SEARCH_CONTENT_MAX_CHARS = parsePositiveInt(
   process.env.CONTEXTSTREAM_SEARCH_MAX_CHARS,
@@ -10669,6 +11474,31 @@ function toStructured(data) {
   }
   return void 0;
 }
+function formatTimingSummary(roundTripMs, resultCount) {
+  if (!SHOW_TIMING) return "";
+  const countStr = resultCount !== void 0 ? `${resultCount} results` : "done";
+  return `\u2713 ${countStr} in ${roundTripMs}ms
+
+`;
+}
+function getResultCount(data) {
+  if (!data || typeof data !== "object") return void 0;
+  const response = data;
+  const dataObj = response.data;
+  if (dataObj?.results && Array.isArray(dataObj.results)) {
+    return dataObj.results.length;
+  }
+  if (typeof dataObj?.total === "number") {
+    return dataObj.total;
+  }
+  if (typeof dataObj?.count === "number") {
+    return dataObj.count;
+  }
+  if (dataObj?.paths && Array.isArray(dataObj.paths)) {
+    return dataObj.paths.length;
+  }
+  return void 0;
+}
 function readStatNumber(payload, key) {
   if (!payload || typeof payload !== "object") return void 0;
   const direct = payload[key];
@@ -11334,10 +12164,10 @@ Hint: Run session_init(folder_path="<your_project_path>") first to establish a s
     );
   }
   async function validateReadableDirectory(inputPath) {
-    const resolvedPath = path5.resolve(inputPath);
+    const resolvedPath = path6.resolve(inputPath);
     let stats;
     try {
-      stats = await fs4.promises.stat(resolvedPath);
+      stats = await fs5.promises.stat(resolvedPath);
     } catch (error) {
       if (error?.code === "ENOENT") {
         return { ok: false, error: `Error: path does not exist: ${inputPath}` };
@@ -11351,7 +12181,7 @@ Hint: Run session_init(folder_path="<your_project_path>") first to establish a s
       return { ok: false, error: `Error: path is not a directory: ${inputPath}` };
     }
     try {
-      await fs4.promises.access(resolvedPath, fs4.constants.R_OK | fs4.constants.X_OK);
+      await fs5.promises.access(resolvedPath, fs5.constants.R_OK | fs5.constants.X_OK);
     } catch (error) {
       return {
         ok: false,
@@ -11774,17 +12604,17 @@ Access: Free`,
       let rulesSkipped = [];
       if (input.folder_path && projectData.id) {
         try {
-          const configDir = path5.join(input.folder_path, ".contextstream");
-          const configPath = path5.join(configDir, "config.json");
-          if (!fs4.existsSync(configDir)) {
-            fs4.mkdirSync(configDir, { recursive: true });
+          const configDir = path6.join(input.folder_path, ".contextstream");
+          const configPath = path6.join(configDir, "config.json");
+          if (!fs5.existsSync(configDir)) {
+            fs5.mkdirSync(configDir, { recursive: true });
           }
           const config = {
             workspace_id: workspaceId,
             project_id: projectData.id,
             project_name: input.name
           };
-          fs4.writeFileSync(configPath, JSON.stringify(config, null, 2));
+          fs5.writeFileSync(configPath, JSON.stringify(config, null, 2));
           if (input.generate_editor_rules) {
             const ruleResults = await writeEditorRules({
               folderPath: input.folder_path,
@@ -12989,10 +13819,17 @@ This does semantic search on the first message. You only need context_smart on s
         auto_index: external_exports.boolean().optional().describe("Automatically create and index project from IDE workspace (default: true)"),
         allow_no_workspace: external_exports.boolean().optional().describe(
           "If true, allow session_init to return connected even if no workspace is resolved (workspace-level tools may not work)."
+        ),
+        skip_project_creation: external_exports.boolean().optional().describe(
+          "If true, skip automatic project creation/matching. Use for parent folders containing multiple projects where you want workspace-level context but no project-specific context."
+        ),
+        is_post_compact: external_exports.boolean().optional().describe(
+          "Set to true when resuming after conversation compaction. This prioritizes session_snapshot restoration and recent decisions."
         )
       })
     },
     async (input) => {
+      const startTime = Date.now();
       let ideRoots = [];
       try {
         const rootsResponse = await server.server.listRoots();
@@ -13008,8 +13845,48 @@ This does semantic search on the first message. You only need context_smart on s
       }
       const result = await client.initSession(input, ideRoots);
       result.tools_hint = getCoreToolsHint();
+      if (input.is_post_compact) {
+        const workspaceIdForRestore = typeof result.workspace_id === "string" ? result.workspace_id : void 0;
+        const projectIdForRestore = typeof result.project_id === "string" ? result.project_id : void 0;
+        if (workspaceIdForRestore) {
+          try {
+            const snapshotSearch = await client.searchEvents({
+              workspace_id: workspaceIdForRestore,
+              project_id: projectIdForRestore,
+              query: "session_snapshot",
+              event_types: ["session_snapshot"],
+              limit: 1
+            });
+            const snapshots = snapshotSearch?.data?.results || snapshotSearch?.results || snapshotSearch?.data || [];
+            if (snapshots && snapshots.length > 0) {
+              const latestSnapshot = snapshots[0];
+              let snapshotData;
+              try {
+                snapshotData = JSON.parse(latestSnapshot.content);
+              } catch {
+                snapshotData = { conversation_summary: latestSnapshot.content };
+              }
+              result.restored_context = {
+                snapshot_id: latestSnapshot.id,
+                captured_at: snapshotData.captured_at || latestSnapshot.created_at,
+                ...snapshotData
+              };
+              result.is_post_compact = true;
+              result.post_compact_hint = "Session restored from pre-compaction snapshot. Review the 'restored_context' to continue where you left off.";
+            } else {
+              result.is_post_compact = true;
+              result.post_compact_hint = "Post-compaction session started, but no snapshots found. Use context_smart to retrieve relevant context.";
+            }
+          } catch (err) {
+            console.error("[ContextStream] Failed to restore post-compact context:", err);
+            result.is_post_compact = true;
+            result.post_compact_hint = "Post-compaction session started. Snapshot restoration failed, use context_smart for context.";
+          }
+        }
+      }
       if (sessionManager) {
         sessionManager.markInitialized(result);
+        sessionManager.resetTokenCount();
       }
       const folderPathForRules = input.folder_path || ideRoots[0] || resolveFolderPath(void 0, sessionManager);
       if (sessionManager && folderPathForRules) {
@@ -13073,7 +13950,7 @@ This does semantic search on the first message. You only need context_smart on s
           formatContent(result)
         ].join("\n");
       } else if (status === "requires_workspace_selection") {
-        const folderName = typeof result.folder_name === "string" ? result.folder_name : typeof input.folder_path === "string" ? path5.basename(input.folder_path) || "this folder" : "this folder";
+        const folderName = typeof result.folder_name === "string" ? result.folder_name : typeof input.folder_path === "string" ? path6.basename(input.folder_path) || "this folder" : "this folder";
         const candidates = Array.isArray(result.workspace_candidates) ? result.workspace_candidates : [];
         const lines = [];
         lines.push(
@@ -13156,6 +14033,12 @@ ${noticeLines.filter(Boolean).join("\n")}`;
         text = `${text}
 
 ${SEARCH_RULES_REMINDER}`;
+      }
+      const roundTripMs = Date.now() - startTime;
+      if (SHOW_TIMING) {
+        text = `\u2713 session initialized in ${roundTripMs}ms
+
+${text}`;
       }
       return {
         content: [{ type: "text", text }],
@@ -13325,7 +14208,7 @@ Behavior:
           "Error: folder_path is required. Provide folder_path or run from a project directory."
         );
       }
-      const folderName = path5.basename(folderPath) || "My Project";
+      const folderName = path6.basename(folderPath) || "My Project";
       let newWorkspace;
       try {
         newWorkspace = await client.createWorkspace({
@@ -13433,8 +14316,11 @@ Use this to persist decisions, insights, preferences, or important information.`
           // Extracted lesson from correction
           "warning",
           // Proactive reminder
-          "frustration"
+          "frustration",
           // User expressed frustration
+          // Compaction awareness
+          "session_snapshot"
+          // Pre-compaction state capture
         ]).describe("Type of context being captured"),
         title: external_exports.string().describe("Brief title for the captured context"),
         content: external_exports.string().describe("Full content/details to capture"),
@@ -13489,6 +14375,224 @@ Use this to persist decisions, insights, preferences, or important information.`
       };
     }
   );
+  registerTool(
+    "session_capture_smart",
+    {
+      title: "Smart capture for conversation compaction",
+      description: `Intelligently capture conversation state before compaction or context loss.
+This creates a session_snapshot that can be restored after compaction.
+
+Use when:
+- Context pressure is high/critical (context_smart returns threshold_warning)
+- Before manual /compact commands
+- When significant work progress needs preservation
+
+Captures:
+- Conversation summary and current goals
+- Active files being worked on
+- Recent decisions with rationale
+- Unfinished work items
+- User preferences expressed in session
+
+The snapshot is automatically prioritized during post-compaction session_init.`,
+      inputSchema: external_exports.object({
+        workspace_id: external_exports.string().uuid().optional(),
+        project_id: external_exports.string().uuid().optional(),
+        conversation_summary: external_exports.string().describe("AI's summary of the conversation so far - what was discussed and accomplished"),
+        current_goal: external_exports.string().optional().describe("The primary goal or task being worked on"),
+        active_files: external_exports.array(external_exports.string()).optional().describe("List of files currently being worked on"),
+        recent_decisions: external_exports.array(
+          external_exports.object({
+            title: external_exports.string(),
+            rationale: external_exports.string().optional()
+          })
+        ).optional().describe("Key decisions made in this session with their rationale"),
+        unfinished_work: external_exports.array(
+          external_exports.object({
+            task: external_exports.string(),
+            status: external_exports.string().optional(),
+            next_steps: external_exports.string().optional()
+          })
+        ).optional().describe("Work items that are in progress or pending"),
+        user_preferences: external_exports.array(external_exports.string()).optional().describe("Preferences expressed by user during this session"),
+        priority_items: external_exports.array(external_exports.string()).optional().describe("User-flagged important items to remember"),
+        metadata: external_exports.record(external_exports.unknown()).optional().describe("Additional context to preserve")
+      })
+    },
+    async (input) => {
+      let workspaceId = input.workspace_id;
+      let projectId = input.project_id;
+      if (!workspaceId && sessionManager) {
+        const ctx = sessionManager.getContext();
+        if (ctx) {
+          workspaceId = ctx.workspace_id;
+          projectId = projectId || ctx.project_id;
+        }
+      }
+      if (!workspaceId) {
+        return errorResult(
+          "Error: workspace_id is required. Please call session_init first or provide workspace_id explicitly."
+        );
+      }
+      const snapshotContent = {
+        conversation_summary: input.conversation_summary,
+        captured_at: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      if (input.current_goal) {
+        snapshotContent.current_goal = input.current_goal;
+      }
+      if (input.active_files?.length) {
+        snapshotContent.active_files = input.active_files;
+      }
+      if (input.recent_decisions?.length) {
+        snapshotContent.recent_decisions = input.recent_decisions;
+      }
+      if (input.unfinished_work?.length) {
+        snapshotContent.unfinished_work = input.unfinished_work;
+      }
+      if (input.user_preferences?.length) {
+        snapshotContent.user_preferences = input.user_preferences;
+      }
+      if (input.priority_items?.length) {
+        snapshotContent.priority_items = input.priority_items;
+      }
+      if (input.metadata) {
+        snapshotContent.metadata = input.metadata;
+      }
+      const result = await client.captureContext({
+        workspace_id: workspaceId,
+        project_id: projectId,
+        event_type: "session_snapshot",
+        title: `Session Snapshot: ${input.current_goal || "Conversation State"}`,
+        content: JSON.stringify(snapshotContent, null, 2),
+        importance: "high",
+        tags: ["session_snapshot", "pre_compaction"]
+      });
+      const response = {
+        ...result,
+        snapshot_id: result?.data?.id || result?.id,
+        message: "Session state captured successfully. This snapshot will be prioritized after compaction.",
+        hint: "After compaction, call session_init with is_post_compact=true to restore this context."
+      };
+      return {
+        content: [{ type: "text", text: formatContent(response) }],
+        structuredContent: toStructured(response)
+      };
+    }
+  );
+  registerTool(
+    "session_restore_context",
+    {
+      title: "Restore context after compaction",
+      description: `Restore conversation context after compaction or context loss.
+Call this after conversation compaction to retrieve saved session state.
+
+Returns structured context including:
+- conversation_summary: What was being discussed
+- current_goal: The primary task being worked on
+- active_files: Files that were being modified
+- recent_decisions: Key decisions made in the session
+- unfinished_work: Tasks that are still in progress
+- user_preferences: Preferences expressed during the session
+
+Use this in combination with session_init(is_post_compact=true) for seamless continuation.`,
+      inputSchema: external_exports.object({
+        workspace_id: external_exports.string().uuid().optional(),
+        project_id: external_exports.string().uuid().optional(),
+        snapshot_id: external_exports.string().uuid().optional().describe("Specific snapshot ID to restore (defaults to most recent)"),
+        max_snapshots: external_exports.number().optional().default(1).describe("Number of recent snapshots to consider (default: 1)")
+      })
+    },
+    async (input) => {
+      let workspaceId = input.workspace_id;
+      let projectId = input.project_id;
+      if (!workspaceId && sessionManager) {
+        const ctx = sessionManager.getContext();
+        if (ctx) {
+          workspaceId = ctx.workspace_id;
+          projectId = projectId || ctx.project_id;
+        }
+      }
+      if (!workspaceId) {
+        return errorResult(
+          "Error: workspace_id is required. Please call session_init first or provide workspace_id explicitly."
+        );
+      }
+      try {
+        if (input.snapshot_id) {
+          const eventResult = await client.getEvent(input.snapshot_id);
+          const event = eventResult?.data || eventResult;
+          if (!event || !event.content) {
+            return errorResult(
+              `Snapshot not found: ${input.snapshot_id}. The snapshot may have been deleted or does not exist.`
+            );
+          }
+          let snapshotData2;
+          try {
+            snapshotData2 = JSON.parse(event.content);
+          } catch {
+            snapshotData2 = { conversation_summary: event.content };
+          }
+          const response2 = {
+            restored: true,
+            snapshot_id: event.id,
+            captured_at: snapshotData2.captured_at || event.created_at,
+            ...snapshotData2,
+            hint: "Context restored. Continue the conversation with awareness of the above state."
+          };
+          return {
+            content: [{ type: "text", text: formatContent(response2) }],
+            structuredContent: toStructured(response2)
+          };
+        }
+        const listResult = await client.listMemoryEvents({
+          workspace_id: workspaceId,
+          project_id: projectId,
+          limit: 50
+          // Fetch more to filter
+        });
+        const allEvents = listResult?.data?.items || listResult?.items || listResult?.data || [];
+        const events = allEvents.filter(
+          (e) => e.event_type === "session_snapshot" || e.metadata?.original_type === "session_snapshot" || e.metadata?.tags?.includes("session_snapshot") || e.tags?.includes("session_snapshot")
+        ).slice(0, input.max_snapshots || 1);
+        if (!events || events.length === 0) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: formatContent({
+                  restored: false,
+                  message: "No session snapshots found. This may be a new session or snapshots have not been captured.",
+                  hint: "Use session_capture_smart to save session state before compaction."
+                })
+              }
+            ]
+          };
+        }
+        const latestEvent = events[0];
+        let snapshotData;
+        try {
+          snapshotData = JSON.parse(latestEvent.content);
+        } catch {
+          snapshotData = { conversation_summary: latestEvent.content };
+        }
+        const response = {
+          restored: true,
+          snapshot_id: latestEvent.id,
+          captured_at: snapshotData.captured_at || latestEvent.created_at,
+          ...snapshotData,
+          hint: "Context restored. Continue the conversation with awareness of the above state."
+        };
+        return {
+          content: [{ type: "text", text: formatContent(response) }],
+          structuredContent: toStructured(response)
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return errorResult(`Failed to restore context: ${message}`);
+      }
+    }
+  );
   registerTool(
     "session_capture_lesson",
     {
@@ -13847,6 +14951,7 @@ Supported editors: ${getAvailableEditors().join(", ")}`,
         overwrite_existing: external_exports.boolean().optional().describe("Allow overwriting existing rule files (ContextStream block only)"),
         apply_global: external_exports.boolean().optional().describe("Also write global rule files for supported editors"),
         install_hooks: external_exports.boolean().optional().describe("Install Claude Code hooks to enforce ContextStream-first search. Defaults to true for Claude users. Set to false to skip."),
+        include_pre_compact: external_exports.boolean().optional().describe("Include PreCompact hook for automatic state saving before context compaction. Defaults to false."),
         dry_run: external_exports.boolean().optional().describe("If true, return content without writing files")
       })
     },
@@ -13927,8 +15032,14 @@ Supported editors: ${getAvailableEditors().join(", ")}`,
               { file: "~/.claude/hooks/contextstream-reminder.py", status: "dry run - would create" },
               { file: "~/.claude/settings.json", status: "dry run - would update" }
             ];
+            if (input.include_pre_compact) {
+              hooksResults.push({ file: "~/.claude/hooks/contextstream-precompact.py", status: "dry run - would create" });
+            }
           } else {
-            const hookResult = await installClaudeCodeHooks({ scope: "user" });
+            const hookResult = await installClaudeCodeHooks({
+              scope: "user",
+              includePreCompact: input.include_pre_compact
+            });
             hooksResults = [
               ...hookResult.scripts.map((f) => ({ file: f, status: "created" })),
               ...hookResult.settings.map((f) => ({ file: f, status: "updated" }))
@@ -14287,10 +15398,13 @@ This saves ~80% tokens compared to including full chat history.`,
         max_tokens: external_exports.number().optional().describe("Maximum tokens for context (default: 800)"),
         format: external_exports.enum(["minified", "readable", "structured"]).optional().describe("Context format (default: minified)"),
         mode: external_exports.enum(["standard", "pack"]).optional().describe("Context pack mode (default: pack when enabled)"),
-        distill: external_exports.boolean().optional().describe("Use distillation for context pack (default: true)")
+        distill: external_exports.boolean().optional().describe("Use distillation for context pack (default: true)"),
+        session_tokens: external_exports.number().optional().describe("Cumulative session token count for context pressure calculation"),
+        context_threshold: external_exports.number().optional().describe("Custom context window threshold (defaults to 70k)")
       })
     },
     async (input) => {
+      const startTime = Date.now();
       if (sessionManager) {
         sessionManager.markContextSmartCalled();
       }
@@ -14303,6 +15417,17 @@ This saves ~80% tokens compared to including full chat history.`,
           projectId = projectId || ctx.project_id;
         }
       }
+      let sessionTokens = input.session_tokens;
+      let contextThreshold = input.context_threshold;
+      if (sessionManager) {
+        if (sessionTokens === void 0) {
+          sessionTokens = sessionManager.getSessionTokens();
+        }
+        if (contextThreshold === void 0) {
+          contextThreshold = sessionManager.getContextThreshold();
+        }
+        sessionManager.addTokens(input.user_message);
+      }
       const result = await client.getSmartContext({
         user_message: input.user_message,
         workspace_id: workspaceId,
@@ -14310,11 +15435,18 @@ This saves ~80% tokens compared to including full chat history.`,
         max_tokens: input.max_tokens,
         format: input.format,
         mode: input.mode,
-        distill: input.distill
+        distill: input.distill,
+        session_tokens: sessionTokens,
+        context_threshold: contextThreshold
       });
+      if (sessionManager && result.token_estimate) {
+        sessionManager.addTokens(result.token_estimate);
+      }
+      const roundTripMs = Date.now() - startTime;
+      const timingStr = SHOW_TIMING ? ` | ${roundTripMs}ms` : "";
       const footer = `
 ---
-\u{1F3AF} ${result.sources_used} sources | ~${result.token_estimate} tokens | format: ${result.format}`;
+\u{1F3AF} ${result.sources_used} sources | ~${result.token_estimate} tokens | format: ${result.format}${timingStr}`;
       const folderPathForRules = resolveFolderPath(void 0, sessionManager);
       const rulesNotice = getRulesNotice(folderPathForRules, detectedClientInfo?.name);
       let versionNotice = result.version_notice;
@@ -14341,6 +15473,22 @@ This saves ~80% tokens compared to including full chat history.`,
       const searchRulesLine = SEARCH_RULES_REMINDER_ENABLED ? `
 
 ${SEARCH_RULES_REMINDER}` : "";
+      let contextPressureWarning = "";
+      if (result.context_pressure) {
+        const cp = result.context_pressure;
+        if (cp.level === "critical") {
+          contextPressureWarning = `
+
+\u{1F6A8} [CONTEXT PRESSURE: CRITICAL] ${cp.usage_percent}% of context used (${cp.session_tokens}/${cp.threshold} tokens)
+Action: ${cp.suggested_action === "save_now" ? 'SAVE STATE NOW - Call session(action="capture") to preserve conversation state before compaction.' : cp.suggested_action}
+The conversation may compact soon. Save important decisions, insights, and progress immediately.`;
+        } else if (cp.level === "high") {
+          contextPressureWarning = `
+
+\u26A0\uFE0F [CONTEXT PRESSURE: HIGH] ${cp.usage_percent}% of context used (${cp.session_tokens}/${cp.threshold} tokens)
+Action: ${cp.suggested_action === "prepare_save" ? "Consider saving important decisions and conversation state soon." : cp.suggested_action}`;
+        }
+      }
       const allWarnings = [
         lessonsWarningLine,
         rulesWarningLine ? `
@@ -14349,6 +15497,7 @@ ${rulesWarningLine}` : "",
         versionWarningLine ? `
 
 ${versionWarningLine}` : "",
+        contextPressureWarning,
         searchRulesLine
       ].filter(Boolean).join("");
       return {
@@ -15379,6 +16528,7 @@ Output formats: full (default, includes content), paths (file paths only - 80% t
       },
       async (input) => {
         const params = normalizeSearchParams(input);
+        const startTime = Date.now();
         let result;
         let toolType;
         switch (input.mode) {
@@ -15409,7 +16559,9 @@ Output formats: full (default, includes content), paths (file paths only - 80% t
           default:
             toolType = "search_hybrid";
         }
-        const outputText = formatContent(result);
+        const roundTripMs = Date.now() - startTime;
+        const timingSummary = formatTimingSummary(roundTripMs, getResultCount(result));
+        const outputText = timingSummary + formatContent(result);
         trackToolTokenSavings(client, toolType, outputText, {
           workspace_id: params.workspace_id,
           project_id: params.project_id
@@ -15424,7 +16576,7 @@ Output formats: full (default, includes content), paths (file paths only - 80% t
       "session",
       {
         title: "Session",
-        description: `Session management operations. Actions: capture (save decision/insight), capture_lesson (save lesson from mistake), get_lessons (retrieve lessons), recall (natural language recall), remember (quick save), user_context (get preferences), summary (workspace summary), compress (compress chat), delta (changes since timestamp), smart_search (context-enriched search), decision_trace (trace decision provenance). Plan actions: capture_plan (save implementation plan), get_plan (retrieve plan with tasks), update_plan (modify plan), list_plans (list all plans).`,
+        description: `Session management operations. Actions: capture (save decision/insight), capture_lesson (save lesson from mistake), get_lessons (retrieve lessons), recall (natural language recall), remember (quick save), user_context (get preferences), summary (workspace summary), compress (compress chat), delta (changes since timestamp), smart_search (context-enriched search), decision_trace (trace decision provenance), restore_context (restore state after compaction). Plan actions: capture_plan (save implementation plan), get_plan (retrieve plan with tasks), update_plan (modify plan), list_plans (list all plans).`,
         inputSchema: external_exports.object({
           action: external_exports.enum([
             "capture",
@@ -15442,7 +16594,9 @@ Output formats: full (default, includes content), paths (file paths only - 80% t
             "capture_plan",
             "get_plan",
             "update_plan",
-            "list_plans"
+            "list_plans",
+            // Context restore
+            "restore_context"
           ]).describe("Action to perform"),
           workspace_id: external_exports.string().uuid().optional(),
           project_id: external_exports.string().uuid().optional(),
@@ -15464,7 +16618,8 @@ Output formats: full (default, includes content), paths (file paths only - 80% t
             "lesson",
             "warning",
             "frustration",
-            "conversation"
+            "conversation",
+            "session_snapshot"
           ]).optional().describe("Event type for capture"),
           importance: external_exports.enum(["low", "medium", "high", "critical"]).optional(),
           tags: external_exports.array(external_exports.string()).optional(),
@@ -15514,7 +16669,10 @@ Output formats: full (default, includes content), paths (file paths only - 80% t
           status: external_exports.enum(["draft", "active", "completed", "archived", "abandoned"]).optional().describe("Plan status"),
           due_at: external_exports.string().optional().describe("Due date for plan (ISO timestamp)"),
           source_tool: external_exports.string().optional().describe("Tool that generated this plan"),
-          include_tasks: external_exports.boolean().optional().describe("Include tasks when getting plan")
+          include_tasks: external_exports.boolean().optional().describe("Include tasks when getting plan"),
+          // Restore context params
+          snapshot_id: external_exports.string().uuid().optional().describe("Specific snapshot ID to restore (defaults to most recent)"),
+          max_snapshots: external_exports.number().optional().default(1).describe("Number of recent snapshots to consider (default: 1)")
         })
       },
       async (input) => {
@@ -15820,6 +16978,87 @@ Output formats: full (default, includes content), paths (file paths only - 80% t
               structuredContent: toStructured(result)
             };
           }
+          case "restore_context": {
+            if (!workspaceId) {
+              return errorResult(
+                "restore_context requires workspace_id. Call session_init first."
+              );
+            }
+            if (input.snapshot_id) {
+              const eventResult = await client.getEvent(input.snapshot_id);
+              const event = eventResult?.data || eventResult;
+              if (!event || !event.content) {
+                return errorResult(
+                  `Snapshot not found: ${input.snapshot_id}. The snapshot may have been deleted or does not exist.`
+                );
+              }
+              let snapshotData;
+              try {
+                snapshotData = JSON.parse(event.content);
+              } catch {
+                snapshotData = { conversation_summary: event.content };
+              }
+              const response2 = {
+                restored: true,
+                snapshot_id: event.id,
+                captured_at: snapshotData.captured_at || event.created_at,
+                ...snapshotData,
+                hint: "Context restored. Continue the conversation with awareness of the above state."
+              };
+              return {
+                content: [{ type: "text", text: formatContent(response2) }],
+                structuredContent: toStructured(response2)
+              };
+            }
+            const listResult = await client.listMemoryEvents({
+              workspace_id: workspaceId,
+              project_id: projectId,
+              limit: 50
+              // Fetch more to filter
+            });
+            const allEvents = listResult?.data?.items || listResult?.items || listResult?.data || [];
+            const snapshotEvents = allEvents.filter(
+              (e) => e.event_type === "session_snapshot" || e.metadata?.original_type === "session_snapshot" || e.metadata?.tags?.includes("session_snapshot") || e.tags?.includes("session_snapshot")
+            ).slice(0, input.max_snapshots || 1);
+            if (!snapshotEvents || snapshotEvents.length === 0) {
+              return {
+                content: [
+                  {
+                    type: "text",
+                    text: formatContent({
+                      restored: false,
+                      message: "No session snapshots found. Use session_capture_smart to save state before compaction.",
+                      hint: "Start fresh or use session_init to get recent context."
+                    })
+                  }
+                ]
+              };
+            }
+            const snapshots = snapshotEvents.map((event) => {
+              let snapshotData;
+              try {
+                snapshotData = JSON.parse(event.content || "{}");
+              } catch {
+                snapshotData = { conversation_summary: event.content };
+              }
+              return {
+                snapshot_id: event.id,
+                captured_at: snapshotData.captured_at || event.created_at,
+                ...snapshotData
+              };
+            });
+            const response = {
+              restored: true,
+              snapshots_found: snapshots.length,
+              latest: snapshots[0],
+              all_snapshots: snapshots.length > 1 ? snapshots : void 0,
+              hint: "Context restored. Continue the conversation with awareness of the above state."
+            };
+            return {
+              content: [{ type: "text", text: formatContent(response) }],
+              structuredContent: toStructured(response)
+            };
+          }
           default:
             return errorResult(`Unknown action: ${input.action}`);
         }
@@ -15829,7 +17068,7 @@ Output formats: full (default, includes content), paths (file paths only - 80% t
       "memory",
       {
         title: "Memory",
-        description: `Memory operations for events and nodes. Event actions: create_event, get_event, update_event, delete_event, list_events, distill_event. Node actions: create_node, get_node, update_node, delete_node, list_nodes, supersede_node. Query actions: search, decisions, timeline, summary. Task actions: create_task (create task, optionally linked to plan), get_task, update_task (can link/unlink task to plan via plan_id), delete_task, list_tasks, reorder_tasks.`,
+        description: `Memory operations for events and nodes. Event actions: create_event, get_event, update_event, delete_event, list_events, distill_event, import_batch (bulk import array of events). Node actions: create_node, get_node, update_node, delete_node, list_nodes, supersede_node. Query actions: search, decisions, timeline, summary. Task actions: create_task (create task, optionally linked to plan), get_task, update_task (can link/unlink task to plan via plan_id), delete_task, list_tasks, reorder_tasks.`,
         inputSchema: external_exports.object({
           action: external_exports.enum([
             "create_event",
@@ -15848,6 +17087,8 @@ Output formats: full (default, includes content), paths (file paths only - 80% t
             "decisions",
             "timeline",
             "summary",
+            // Batch actions
+            "import_batch",
             // Task actions
             "create_task",
             "get_task",
@@ -15908,7 +17149,33 @@ Output formats: full (default, includes content), paths (file paths only - 80% t
           order: external_exports.number().optional().describe("Task order within plan"),
           task_ids: external_exports.array(external_exports.string().uuid()).optional().describe("Task IDs for reorder_tasks"),
           blocked_reason: external_exports.string().optional().describe("Reason when task is blocked"),
-          tags: external_exports.array(external_exports.string()).optional().describe("Tags for task")
+          tags: external_exports.array(external_exports.string()).optional().describe("Tags for task"),
+          // Batch import params
+          events: external_exports.array(
+            external_exports.object({
+              event_type: external_exports.string(),
+              title: external_exports.string(),
+              content: external_exports.string(),
+              metadata: external_exports.record(external_exports.any()).optional(),
+              provenance: external_exports.object({
+                repo: external_exports.string().optional(),
+                branch: external_exports.string().optional(),
+                commit_sha: external_exports.string().optional(),
+                pr_url: external_exports.string().url().optional(),
+                issue_url: external_exports.string().url().optional(),
+                slack_thread_url: external_exports.string().url().optional()
+              }).optional(),
+              code_refs: external_exports.array(
+                external_exports.object({
+                  file_path: external_exports.string(),
+                  symbol_id: external_exports.string().optional(),
+                  symbol_name: external_exports.string().optional()
+                })
+              ).optional(),
+              tags: external_exports.array(external_exports.string()).optional(),
+              occurred_at: external_exports.string().optional().describe("ISO timestamp for when the event occurred")
+            })
+          ).optional().describe("Array of events for import_batch action")
         })
       },
       async (input) => {
@@ -15979,6 +17246,36 @@ Output formats: full (default, includes content), paths (file paths only - 80% t
               structuredContent: toStructured(result)
             };
           }
+          case "import_batch": {
+            if (!input.events || !Array.isArray(input.events) || input.events.length === 0) {
+              return errorResult("import_batch requires: events (non-empty array of event objects)");
+            }
+            if (!workspaceId) {
+              return errorResult("import_batch requires workspace_id. Call session_init first.");
+            }
+            const eventsWithContext = input.events.map((event) => ({
+              ...event,
+              workspace_id: workspaceId,
+              project_id: projectId || event.project_id
+            }));
+            const result = await client.bulkIngestEvents({
+              workspace_id: workspaceId,
+              project_id: projectId,
+              events: eventsWithContext
+            });
+            const count = Array.isArray(result) ? result.length : result?.data?.length ?? 0;
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `\u2705 Imported ${count} event(s) successfully.
+
+${formatContent(result)}`
+                }
+              ],
+              structuredContent: toStructured(result)
+            };
+          }
           case "distill_event": {
             if (!input.event_id) {
               return errorResult("distill_event requires: event_id");
@@ -18327,6 +19624,7 @@ function registerPrompts(server) {
 
 // src/session-manager.ts
 var SessionManager = class {
+  // Conservative default for 100k context window
   constructor(server, client) {
     this.server = server;
     this.client = client;
@@ -18337,6 +19635,9 @@ var SessionManager = class {
     this.folderPath = null;
     this.contextSmartCalled = false;
     this.warningShown = false;
+    // Token tracking for context pressure calculation
+    this.sessionTokens = 0;
+    this.contextThreshold = 7e4;
   }
   /**
    * Check if session has been auto-initialized
@@ -18375,8 +19676,8 @@ var SessionManager = class {
   /**
    * Set the folder path hint (can be passed from tools that know the workspace path)
    */
-  setFolderPath(path8) {
-    this.folderPath = path8;
+  setFolderPath(path9) {
+    this.folderPath = path9;
   }
   /**
    * Mark that context_smart has been called in this session
@@ -18384,6 +19685,51 @@ var SessionManager = class {
   markContextSmartCalled() {
     this.contextSmartCalled = true;
   }
+  /**
+   * Get current session token count for context pressure calculation.
+   */
+  getSessionTokens() {
+    return this.sessionTokens;
+  }
+  /**
+   * Get the context threshold (max tokens before compaction warning).
+   */
+  getContextThreshold() {
+    return this.contextThreshold;
+  }
+  /**
+   * Set a custom context threshold (useful if client provides model info).
+   */
+  setContextThreshold(threshold) {
+    this.contextThreshold = threshold;
+  }
+  /**
+   * Add tokens to the session count.
+   * Call this after each tool response to track token accumulation.
+   *
+   * @param tokens - Exact token count or text to estimate
+   */
+  addTokens(tokens) {
+    if (typeof tokens === "number") {
+      this.sessionTokens += tokens;
+    } else {
+      this.sessionTokens += Math.ceil(tokens.length / 4);
+    }
+  }
+  /**
+   * Estimate tokens from a tool response.
+   * Uses a simple heuristic: ~4 characters per token.
+   */
+  estimateTokens(content) {
+    const text = typeof content === "string" ? content : JSON.stringify(content);
+    return Math.ceil(text.length / 4);
+  }
+  /**
+   * Reset token count (e.g., after compaction or new session).
+   */
+  resetTokenCount() {
+    this.sessionTokens = 0;
+  }
   /**
    * Check if context_smart has been called and warn if not.
    * Returns true if a warning was shown, false otherwise.
@@ -18452,7 +19798,7 @@ var SessionManager = class {
     }
     if (this.ideRoots.length === 0) {
       const cwd = process.cwd();
-      const fs7 = await import("fs");
+      const fs8 = await import("fs");
       const projectIndicators = [
         ".git",
         "package.json",
@@ -18462,7 +19808,7 @@ var SessionManager = class {
       ];
       const hasProjectIndicator = projectIndicators.some((f) => {
         try {
-          return fs7.existsSync(`${cwd}/${f}`);
+          return fs8.existsSync(`${cwd}/${f}`);
         } catch {
           return false;
         }
@@ -18935,24 +20281,24 @@ async function runHttpGateway() {
 // src/index.ts
 import { existsSync as existsSync4, mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "fs";
 import { homedir as homedir6 } from "os";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 
 // src/setup.ts
-import * as fs6 from "node:fs/promises";
-import * as path7 from "node:path";
+import * as fs7 from "node:fs/promises";
+import * as path8 from "node:path";
 import { homedir as homedir5 } from "node:os";
 import { stdin, stdout } from "node:process";
 import { createInterface } from "node:readline/promises";
 
 // src/credentials.ts
-import * as fs5 from "node:fs/promises";
-import * as path6 from "node:path";
+import * as fs6 from "node:fs/promises";
+import * as path7 from "node:path";
 import { homedir as homedir4 } from "node:os";
 function normalizeApiUrl(input) {
   return String(input ?? "").trim().replace(/\/+$/, "");
 }
 function credentialsFilePath() {
-  return path6.join(homedir4(), ".contextstream", "credentials.json");
+  return path7.join(homedir4(), ".contextstream", "credentials.json");
 }
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -18960,7 +20306,7 @@ function isRecord(value) {
 async function readSavedCredentials() {
   const filePath = credentialsFilePath();
   try {
-    const raw = await fs5.readFile(filePath, "utf8");
+    const raw = await fs6.readFile(filePath, "utf8");
     const parsed = JSON.parse(raw);
     if (!isRecord(parsed)) return null;
     const version = parsed.version;
@@ -18986,7 +20332,7 @@ async function readSavedCredentials() {
 }
 async function writeSavedCredentials(input) {
   const filePath = credentialsFilePath();
-  await fs5.mkdir(path6.dirname(filePath), { recursive: true });
+  await fs6.mkdir(path7.dirname(filePath), { recursive: true });
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const existing = await readSavedCredentials();
   const value = {
@@ -18998,9 +20344,9 @@ async function writeSavedCredentials(input) {
     updated_at: now
   };
   const body = JSON.stringify(value, null, 2) + "\n";
-  await fs5.writeFile(filePath, body, { encoding: "utf8", mode: 384 });
+  await fs6.writeFile(filePath, body, { encoding: "utf8", mode: 384 });
   try {
-    await fs5.chmod(filePath, 384);
+    await fs6.chmod(filePath, 384);
   } catch {
   }
   return { path: filePath, value };
@@ -19045,7 +20391,7 @@ function parseNumberList(input, max) {
 }
 async function fileExists(filePath) {
   try {
-    await fs6.stat(filePath);
+    await fs7.stat(filePath);
     return true;
   } catch {
     return false;
@@ -19209,41 +20555,41 @@ function replaceContextStreamBlock2(existing, content) {
   return { content: appended, status: "appended" };
 }
 async function upsertTextFile(filePath, content, _marker) {
-  await fs6.mkdir(path7.dirname(filePath), { recursive: true });
+  await fs7.mkdir(path8.dirname(filePath), { recursive: true });
   const exists = await fileExists(filePath);
   const wrappedContent = wrapWithMarkers2(content);
   if (!exists) {
-    await fs6.writeFile(filePath, wrappedContent + "\n", "utf8");
+    await fs7.writeFile(filePath, wrappedContent + "\n", "utf8");
     return "created";
   }
-  const existing = await fs6.readFile(filePath, "utf8").catch(() => "");
+  const existing = await fs7.readFile(filePath, "utf8").catch(() => "");
   if (!existing.trim()) {
-    await fs6.writeFile(filePath, wrappedContent + "\n", "utf8");
+    await fs7.writeFile(filePath, wrappedContent + "\n", "utf8");
     return "updated";
   }
   const replaced = replaceContextStreamBlock2(existing, content);
-  await fs6.writeFile(filePath, replaced.content, "utf8");
+  await fs7.writeFile(filePath, replaced.content, "utf8");
   return replaced.status;
 }
 function globalRulesPathForEditor(editor) {
   const home = homedir5();
   switch (editor) {
     case "codex":
-      return path7.join(home, ".codex", "AGENTS.md");
+      return path8.join(home, ".codex", "AGENTS.md");
     case "claude":
-      return path7.join(home, ".claude", "CLAUDE.md");
+      return path8.join(home, ".claude", "CLAUDE.md");
     case "windsurf":
-      return path7.join(home, ".codeium", "windsurf", "memories", "global_rules.md");
+      return path8.join(home, ".codeium", "windsurf", "memories", "global_rules.md");
     case "cline":
-      return path7.join(home, "Documents", "Cline", "Rules", "contextstream.md");
+      return path8.join(home, "Documents", "Cline", "Rules", "contextstream.md");
     case "kilo":
-      return path7.join(home, ".kilocode", "rules", "contextstream.md");
+      return path8.join(home, ".kilocode", "rules", "contextstream.md");
     case "roo":
-      return path7.join(home, ".roo", "rules", "contextstream.md");
+      return path8.join(home, ".roo", "rules", "contextstream.md");
     case "aider":
-      return path7.join(home, ".aider.conf.yml");
+      return path8.join(home, ".aider.conf.yml");
     case "antigravity":
-      return path7.join(home, ".gemini", "GEMINI.md");
+      return path8.join(home, ".gemini", "GEMINI.md");
     case "cursor":
       return null;
     default:
@@ -19261,40 +20607,40 @@ async function isCodexInstalled() {
   const envHome = process.env.CODEX_HOME;
   const candidates = [
     envHome,
-    path7.join(home, ".codex"),
-    path7.join(home, ".codex", "config.toml"),
-    path7.join(home, ".config", "codex")
+    path8.join(home, ".codex"),
+    path8.join(home, ".codex", "config.toml"),
+    path8.join(home, ".config", "codex")
   ].filter((candidate) => Boolean(candidate));
   return anyPathExists(candidates);
 }
 async function isClaudeInstalled() {
   const home = homedir5();
-  const candidates = [path7.join(home, ".claude"), path7.join(home, ".config", "claude")];
+  const candidates = [path8.join(home, ".claude"), path8.join(home, ".config", "claude")];
   const desktopConfig = claudeDesktopConfigPath();
   if (desktopConfig) candidates.push(desktopConfig);
   if (process.platform === "darwin") {
-    candidates.push(path7.join(home, "Library", "Application Support", "Claude"));
+    candidates.push(path8.join(home, "Library", "Application Support", "Claude"));
   } else if (process.platform === "win32") {
     const appData = process.env.APPDATA;
-    if (appData) candidates.push(path7.join(appData, "Claude"));
+    if (appData) candidates.push(path8.join(appData, "Claude"));
   }
   return anyPathExists(candidates);
 }
 async function isWindsurfInstalled() {
   const home = homedir5();
   const candidates = [
-    path7.join(home, ".codeium"),
-    path7.join(home, ".codeium", "windsurf"),
-    path7.join(home, ".config", "codeium")
+    path8.join(home, ".codeium"),
+    path8.join(home, ".codeium", "windsurf"),
+    path8.join(home, ".config", "codeium")
   ];
   if (process.platform === "darwin") {
-    candidates.push(path7.join(home, "Library", "Application Support", "Windsurf"));
-    candidates.push(path7.join(home, "Library", "Application Support", "Codeium"));
+    candidates.push(path8.join(home, "Library", "Application Support", "Windsurf"));
+    candidates.push(path8.join(home, "Library", "Application Support", "Codeium"));
   } else if (process.platform === "win32") {
     const appData = process.env.APPDATA;
     if (appData) {
-      candidates.push(path7.join(appData, "Windsurf"));
-      candidates.push(path7.join(appData, "Codeium"));
+      candidates.push(path8.join(appData, "Windsurf"));
+      candidates.push(path8.join(appData, "Codeium"));
     }
   }
   return anyPathExists(candidates);
@@ -19302,42 +20648,42 @@ async function isWindsurfInstalled() {
 async function isClineInstalled() {
   const home = homedir5();
   const candidates = [
-    path7.join(home, "Documents", "Cline"),
-    path7.join(home, ".cline"),
-    path7.join(home, ".config", "cline")
+    path8.join(home, "Documents", "Cline"),
+    path8.join(home, ".cline"),
+    path8.join(home, ".config", "cline")
   ];
   return anyPathExists(candidates);
 }
 async function isKiloInstalled() {
   const home = homedir5();
-  const candidates = [path7.join(home, ".kilocode"), path7.join(home, ".config", "kilocode")];
+  const candidates = [path8.join(home, ".kilocode"), path8.join(home, ".config", "kilocode")];
   return anyPathExists(candidates);
 }
 async function isRooInstalled() {
   const home = homedir5();
-  const candidates = [path7.join(home, ".roo"), path7.join(home, ".config", "roo")];
+  const candidates = [path8.join(home, ".roo"), path8.join(home, ".config", "roo")];
   return anyPathExists(candidates);
 }
 async function isAiderInstalled() {
   const home = homedir5();
-  const candidates = [path7.join(home, ".aider.conf.yml"), path7.join(home, ".config", "aider")];
+  const candidates = [path8.join(home, ".aider.conf.yml"), path8.join(home, ".config", "aider")];
   return anyPathExists(candidates);
 }
 async function isCursorInstalled() {
   const home = homedir5();
-  const candidates = [path7.join(home, ".cursor")];
+  const candidates = [path8.join(home, ".cursor")];
   if (process.platform === "darwin") {
     candidates.push("/Applications/Cursor.app");
-    candidates.push(path7.join(home, "Applications", "Cursor.app"));
-    candidates.push(path7.join(home, "Library", "Application Support", "Cursor"));
+    candidates.push(path8.join(home, "Applications", "Cursor.app"));
+    candidates.push(path8.join(home, "Library", "Application Support", "Cursor"));
   } else if (process.platform === "win32") {
     const localApp = process.env.LOCALAPPDATA;
     const programFiles = process.env.ProgramFiles;
     const programFilesX86 = process.env["ProgramFiles(x86)"];
-    if (localApp) candidates.push(path7.join(localApp, "Programs", "Cursor", "Cursor.exe"));
-    if (localApp) candidates.push(path7.join(localApp, "Cursor", "Cursor.exe"));
-    if (programFiles) candidates.push(path7.join(programFiles, "Cursor", "Cursor.exe"));
-    if (programFilesX86) candidates.push(path7.join(programFilesX86, "Cursor", "Cursor.exe"));
+    if (localApp) candidates.push(path8.join(localApp, "Programs", "Cursor", "Cursor.exe"));
+    if (localApp) candidates.push(path8.join(localApp, "Cursor", "Cursor.exe"));
+    if (programFiles) candidates.push(path8.join(programFiles, "Cursor", "Cursor.exe"));
+    if (programFilesX86) candidates.push(path8.join(programFilesX86, "Cursor", "Cursor.exe"));
   } else {
     candidates.push("/usr/bin/cursor");
     candidates.push("/usr/local/bin/cursor");
@@ -19348,19 +20694,19 @@ async function isCursorInstalled() {
 }
 async function isAntigravityInstalled() {
   const home = homedir5();
-  const candidates = [path7.join(home, ".gemini")];
+  const candidates = [path8.join(home, ".gemini")];
   if (process.platform === "darwin") {
     candidates.push("/Applications/Antigravity.app");
-    candidates.push(path7.join(home, "Applications", "Antigravity.app"));
-    candidates.push(path7.join(home, "Library", "Application Support", "Antigravity"));
+    candidates.push(path8.join(home, "Applications", "Antigravity.app"));
+    candidates.push(path8.join(home, "Library", "Application Support", "Antigravity"));
   } else if (process.platform === "win32") {
     const localApp = process.env.LOCALAPPDATA;
     const programFiles = process.env.ProgramFiles;
     const programFilesX86 = process.env["ProgramFiles(x86)"];
-    if (localApp) candidates.push(path7.join(localApp, "Programs", "Antigravity", "Antigravity.exe"));
-    if (localApp) candidates.push(path7.join(localApp, "Antigravity", "Antigravity.exe"));
-    if (programFiles) candidates.push(path7.join(programFiles, "Antigravity", "Antigravity.exe"));
-    if (programFilesX86) candidates.push(path7.join(programFilesX86, "Antigravity", "Antigravity.exe"));
+    if (localApp) candidates.push(path8.join(localApp, "Programs", "Antigravity", "Antigravity.exe"));
+    if (localApp) candidates.push(path8.join(localApp, "Antigravity", "Antigravity.exe"));
+    if (programFiles) candidates.push(path8.join(programFiles, "Antigravity", "Antigravity.exe"));
+    if (programFilesX86) candidates.push(path8.join(programFilesX86, "Antigravity", "Antigravity.exe"));
   } else {
     candidates.push("/usr/bin/antigravity");
     candidates.push("/usr/local/bin/antigravity");
@@ -19403,6 +20749,9 @@ function buildContextStreamMcpServer(params) {
     env.CONTEXTSTREAM_PROGRESSIVE_MODE = "true";
   }
   env.CONTEXTSTREAM_CONTEXT_PACK = params.contextPackEnabled === false ? "false" : "true";
+  if (params.showTiming) {
+    env.CONTEXTSTREAM_SHOW_TIMING = "true";
+  }
   if (IS_WINDOWS) {
     return {
       command: "cmd",
@@ -19425,6 +20774,9 @@ function buildContextStreamVsCodeServer(params) {
     env.CONTEXTSTREAM_PROGRESSIVE_MODE = "true";
   }
   env.CONTEXTSTREAM_CONTEXT_PACK = params.contextPackEnabled === false ? "false" : "true";
+  if (params.showTiming) {
+    env.CONTEXTSTREAM_SHOW_TIMING = "true";
+  }
   if (IS_WINDOWS) {
     return {
       type: "stdio",
@@ -19459,11 +20811,11 @@ function tryParseJsonLike(raw) {
   }
 }
 async function upsertJsonMcpConfig(filePath, server) {
-  await fs6.mkdir(path7.dirname(filePath), { recursive: true });
+  await fs7.mkdir(path8.dirname(filePath), { recursive: true });
   const exists = await fileExists(filePath);
   let root = {};
   if (exists) {
-    const raw = await fs6.readFile(filePath, "utf8").catch(() => "");
+    const raw = await fs7.readFile(filePath, "utf8").catch(() => "");
     const parsed = tryParseJsonLike(raw);
     if (!parsed.ok) throw new Error(`Invalid JSON in ${filePath}: ${parsed.error}`);
     root = parsed.value;
@@ -19474,16 +20826,16 @@ async function upsertJsonMcpConfig(filePath, server) {
   const before = JSON.stringify(root.mcpServers.contextstream ?? null);
   root.mcpServers.contextstream = server;
   const after = JSON.stringify(root.mcpServers.contextstream ?? null);
-  await fs6.writeFile(filePath, JSON.stringify(root, null, 2) + "\n", "utf8");
+  await fs7.writeFile(filePath, JSON.stringify(root, null, 2) + "\n", "utf8");
   if (!exists) return "created";
   return before === after ? "skipped" : "updated";
 }
 async function upsertJsonVsCodeMcpConfig(filePath, server) {
-  await fs6.mkdir(path7.dirname(filePath), { recursive: true });
+  await fs7.mkdir(path8.dirname(filePath), { recursive: true });
   const exists = await fileExists(filePath);
   let root = {};
   if (exists) {
-    const raw = await fs6.readFile(filePath, "utf8").catch(() => "");
+    const raw = await fs7.readFile(filePath, "utf8").catch(() => "");
     const parsed = tryParseJsonLike(raw);
     if (!parsed.ok) throw new Error(`Invalid JSON in ${filePath}: ${parsed.error}`);
     root = parsed.value;
@@ -19494,14 +20846,14 @@ async function upsertJsonVsCodeMcpConfig(filePath, server) {
   const before = JSON.stringify(root.servers.contextstream ?? null);
   root.servers.contextstream = server;
   const after = JSON.stringify(root.servers.contextstream ?? null);
-  await fs6.writeFile(filePath, JSON.stringify(root, null, 2) + "\n", "utf8");
+  await fs7.writeFile(filePath, JSON.stringify(root, null, 2) + "\n", "utf8");
   if (!exists) return "created";
   return before === after ? "skipped" : "updated";
 }
 function claudeDesktopConfigPath() {
   const home = homedir5();
   if (process.platform === "darwin") {
-    return path7.join(
+    return path8.join(
       home,
       "Library",
       "Application Support",
@@ -19510,21 +20862,23 @@ function claudeDesktopConfigPath() {
     );
   }
   if (process.platform === "win32") {
-    const appData = process.env.APPDATA || path7.join(home, "AppData", "Roaming");
-    return path7.join(appData, "Claude", "claude_desktop_config.json");
+    const appData = process.env.APPDATA || path8.join(home, "AppData", "Roaming");
+    return path8.join(appData, "Claude", "claude_desktop_config.json");
   }
   return null;
 }
 async function upsertCodexTomlConfig(filePath, params) {
-  await fs6.mkdir(path7.dirname(filePath), { recursive: true });
+  await fs7.mkdir(path8.dirname(filePath), { recursive: true });
   const exists = await fileExists(filePath);
-  const existing = exists ? await fs6.readFile(filePath, "utf8").catch(() => "") : "";
+  const existing = exists ? await fs7.readFile(filePath, "utf8").catch(() => "") : "";
   const marker = "[mcp_servers.contextstream]";
   const envMarker = "[mcp_servers.contextstream.env]";
   const toolsetLine = params.toolset === "router" ? `CONTEXTSTREAM_PROGRESSIVE_MODE = "true"
 ` : "";
   const contextPackLine = `CONTEXTSTREAM_CONTEXT_PACK = "${params.contextPackEnabled === false ? "false" : "true"}"
 `;
+  const showTimingLine = params.showTiming ? `CONTEXTSTREAM_SHOW_TIMING = "true"
+` : "";
   const commandLine = IS_WINDOWS ? `command = "cmd"
 args = ["/c", "npx", "-y", "@contextstream/mcp-server"]
 ` : `command = "npx"
@@ -19538,17 +20892,17 @@ args = ["-y", "@contextstream/mcp-server"]
 [mcp_servers.contextstream.env]
 CONTEXTSTREAM_API_URL = "${params.apiUrl}"
 CONTEXTSTREAM_API_KEY = "${params.apiKey}"
-` + toolsetLine + contextPackLine;
+` + toolsetLine + contextPackLine + showTimingLine;
   if (!exists) {
-    await fs6.writeFile(filePath, block.trimStart(), "utf8");
+    await fs7.writeFile(filePath, block.trimStart(), "utf8");
     return "created";
   }
   if (!existing.includes(marker)) {
-    await fs6.writeFile(filePath, existing.trimEnd() + block, "utf8");
+    await fs7.writeFile(filePath, existing.trimEnd() + block, "utf8");
     return "updated";
   }
   if (!existing.includes(envMarker)) {
-    await fs6.writeFile(
+    await fs7.writeFile(
       filePath,
       existing.trimEnd() + "\n\n" + envMarker + `
 CONTEXTSTREAM_API_URL = "${params.apiUrl}"
@@ -19609,18 +20963,18 @@ CONTEXTSTREAM_API_KEY = "${params.apiKey}"
   }
   const updated = out.join("\n");
   if (updated === existing) return "skipped";
-  await fs6.writeFile(filePath, updated, "utf8");
+  await fs7.writeFile(filePath, updated, "utf8");
   return "updated";
 }
 async function discoverProjectsUnderFolder(parentFolder) {
-  const entries = await fs6.readdir(parentFolder, { withFileTypes: true });
-  const candidates = entries.filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => path7.join(parentFolder, e.name));
+  const entries = await fs7.readdir(parentFolder, { withFileTypes: true });
+  const candidates = entries.filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => path8.join(parentFolder, e.name));
   const projects = [];
   for (const dir of candidates) {
-    const hasGit = await fileExists(path7.join(dir, ".git"));
-    const hasPkg = await fileExists(path7.join(dir, "package.json"));
-    const hasCargo = await fileExists(path7.join(dir, "Cargo.toml"));
-    const hasPyProject = await fileExists(path7.join(dir, "pyproject.toml"));
+    const hasGit = await fileExists(path8.join(dir, ".git"));
+    const hasPkg = await fileExists(path8.join(dir, "package.json"));
+    const hasCargo = await fileExists(path8.join(dir, "Cargo.toml"));
+    const hasPyProject = await fileExists(path8.join(dir, "pyproject.toml"));
     if (hasGit || hasPkg || hasCargo || hasPyProject) projects.push(dir);
   }
   return projects;
@@ -19895,6 +21249,11 @@ Detected plan: ${planLabel} (graph: ${graphTierLabel})`);
     console.log("  Uses more operations/credits; can be disabled in settings or via env.");
     const contextPackChoice = normalizeInput(await rl.question("Enable Context Pack? [Y/n]: "));
     const contextPackEnabled = !(contextPackChoice.toLowerCase() === "n" || contextPackChoice.toLowerCase() === "no");
+    console.log("\nResponse Timing:");
+    console.log("  Show response time for tool calls (e.g., '\u2713 3 results in 142ms').");
+    console.log("  Useful for debugging performance; disabled by default.");
+    const showTimingChoice = normalizeInput(await rl.question("Show response timing? [y/N]: "));
+    const showTiming = showTimingChoice.toLowerCase() === "y" || showTimingChoice.toLowerCase() === "yes";
     const editors = [
       "codex",
       "claude",
@@ -19969,18 +21328,20 @@ Detected plan: ${planLabel} (graph: ${graphTierLabel})`);
       )
     ) || mcpChoiceDefault;
     const mcpScope = mcpChoice === "2" && hasCodex && !hasProjectMcpEditors ? "skip" : mcpChoice === "4" ? "skip" : mcpChoice === "1" ? "global" : mcpChoice === "2" ? "project" : "both";
-    const mcpServer = buildContextStreamMcpServer({ apiUrl, apiKey, toolset, contextPackEnabled });
+    const mcpServer = buildContextStreamMcpServer({ apiUrl, apiKey, toolset, contextPackEnabled, showTiming });
     const mcpServerClaude = buildContextStreamMcpServer({
       apiUrl,
       apiKey,
       toolset,
-      contextPackEnabled
+      contextPackEnabled,
+      showTiming
     });
     const vsCodeServer = buildContextStreamVsCodeServer({
       apiUrl,
       apiKey,
       toolset,
-      contextPackEnabled
+      contextPackEnabled,
+      showTiming
     });
     const needsGlobalMcpConfig = mcpScope === "global" || mcpScope === "both" || mcpScope === "project" && hasCodex;
     if (needsGlobalMcpConfig) {
@@ -19989,7 +21350,7 @@ Detected plan: ${planLabel} (graph: ${graphTierLabel})`);
         if (mcpScope === "project" && editor !== "codex") continue;
         try {
           if (editor === "codex") {
-            const filePath = path7.join(homedir5(), ".codex", "config.toml");
+            const filePath = path8.join(homedir5(), ".codex", "config.toml");
             if (dryRun) {
               writeActions.push({ kind: "mcp-config", target: filePath, status: "dry-run" });
               console.log(`- ${EDITOR_LABELS[editor]}: would update ${filePath}`);
@@ -19999,14 +21360,15 @@ Detected plan: ${planLabel} (graph: ${graphTierLabel})`);
               apiUrl,
               apiKey,
               toolset,
-              contextPackEnabled
+              contextPackEnabled,
+              showTiming
             });
             writeActions.push({ kind: "mcp-config", target: filePath, status });
             console.log(`- ${EDITOR_LABELS[editor]}: ${status} ${filePath}`);
             continue;
           }
           if (editor === "windsurf") {
-            const filePath = path7.join(homedir5(), ".codeium", "windsurf", "mcp_config.json");
+            const filePath = path8.join(homedir5(), ".codeium", "windsurf", "mcp_config.json");
             if (dryRun) {
               writeActions.push({ kind: "mcp-config", target: filePath, status: "dry-run" });
               console.log(`- ${EDITOR_LABELS[editor]}: would update ${filePath}`);
@@ -20048,7 +21410,7 @@ Detected plan: ${planLabel} (graph: ${graphTierLabel})`);
             continue;
           }
           if (editor === "cursor") {
-            const filePath = path7.join(homedir5(), ".cursor", "mcp.json");
+            const filePath = path8.join(homedir5(), ".cursor", "mcp.json");
             if (dryRun) {
               writeActions.push({ kind: "mcp-config", target: filePath, status: "dry-run" });
               console.log(`- ${EDITOR_LABELS[editor]}: would update ${filePath}`);
@@ -20106,9 +21468,9 @@ Detected plan: ${planLabel} (graph: ${graphTierLabel})`);
           if (dryRun) {
             console.log("- Would install hooks to ~/.claude/hooks/");
             console.log("- Would update ~/.claude/settings.json");
-            writeActions.push({ kind: "mcp-config", target: path7.join(homedir5(), ".claude", "hooks", "contextstream-redirect.py"), status: "dry-run" });
-            writeActions.push({ kind: "mcp-config", target: path7.join(homedir5(), ".claude", "hooks", "contextstream-reminder.py"), status: "dry-run" });
-            writeActions.push({ kind: "mcp-config", target: path7.join(homedir5(), ".claude", "settings.json"), status: "dry-run" });
+            writeActions.push({ kind: "mcp-config", target: path8.join(homedir5(), ".claude", "hooks", "contextstream-redirect.py"), status: "dry-run" });
+            writeActions.push({ kind: "mcp-config", target: path8.join(homedir5(), ".claude", "hooks", "contextstream-reminder.py"), status: "dry-run" });
+            writeActions.push({ kind: "mcp-config", target: path8.join(homedir5(), ".claude", "settings.json"), status: "dry-run" });
           } else {
             const result = await installClaudeCodeHooks({ scope: "user" });
             result.scripts.forEach((script) => {
@@ -20130,6 +21492,102 @@ Detected plan: ${planLabel} (graph: ${graphTierLabel})`);
         console.log("  Note: Without hooks, Claude may still use default tools instead of ContextStream.");
       }
     }
+    console.log("\n\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510");
+    console.log("\u2502  Code Privacy & Indexing                                        \u2502");
+    console.log("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518");
+    console.log("");
+    console.log("  Your code is protected:");
+    console.log("    \u2713 Encrypted in transit (TLS 1.3) and at rest (AES-256)");
+    console.log("    \u2713 Isolated per workspace \u2014 no cross-tenant access");
+    console.log("    \u2713 You can delete your data anytime");
+    console.log("");
+    console.log("  As an additional measure, you can exclude specific files from indexing");
+    console.log("  using .contextstream/ignore (gitignore syntax). Already excluded:");
+    console.log("    \u2022 node_modules, vendor, .git, build outputs, lock files");
+    console.log("");
+    console.log("  Optional: Add patterns for extra-sensitive files like:");
+    console.log("    \u2022 customer-data/ \u2014 client-specific data");
+    console.log("    \u2022 **/*.pem, **/*.key \u2014 private keys & certificates");
+    console.log("    \u2022 src/legacy/ \u2014 code you don't need indexed");
+    console.log("");
+    const createIgnoreFile = normalizeInput(
+      await rl.question("Create a sample .contextstream/ignore file? [y/N]: ")
+    ).toLowerCase();
+    if (createIgnoreFile === "y" || createIgnoreFile === "yes") {
+      const ignoreContent = `# .contextstream/ignore - Additional exclusions from ContextStream indexing
+# Uses gitignore syntax: https://git-scm.com/docs/gitignore
+#
+# Note: Your code is already protected with encryption (TLS 1.3 + AES-256)
+# and workspace isolation. This file is for extra-sensitive paths you prefer
+# to keep completely off the index.
+
+# Customer/sensitive data
+**/customer-data/
+**/secrets/
+**/*.pem
+**/*.key
+
+# Large generated files
+**/generated/
+**/*.min.js
+**/*.min.css
+
+# Test fixtures with sensitive data
+**/fixtures/production/
+**/test-data/real/
+
+# Vendor code you don't want indexed
+**/third-party/
+**/external-libs/
+
+# Specific paths in your project (uncomment as needed)
+# src/legacy/
+# docs/internal/
+`;
+      console.log("\nWhere to create .contextstream/ignore?");
+      console.log(`  1) Current folder (${process.cwd()})`);
+      console.log("  2) Home folder (applies globally)");
+      console.log("  3) I'll add it to specific projects later");
+      const ignoreLocation = normalizeInput(await rl.question("Choose [1/2/3] (default 1): ")) || "1";
+      if (ignoreLocation === "1" || ignoreLocation === "2") {
+        const baseDir = ignoreLocation === "1" ? process.cwd() : homedir5();
+        const ignoreDir = path8.join(baseDir, ".contextstream");
+        const ignorePath = path8.join(ignoreDir, "ignore");
+        if (dryRun) {
+          writeActions.push({ kind: "rules", target: ignorePath, status: "dry-run" });
+          console.log(`- Would create ${ignorePath}`);
+        } else {
+          try {
+            await fs7.mkdir(ignoreDir, { recursive: true });
+            const exists = await fileExists(ignorePath);
+            if (exists) {
+              const overwrite = normalizeInput(
+                await rl.question(`${ignorePath} already exists. Overwrite? [y/N]: `)
+              ).toLowerCase();
+              if (overwrite !== "y" && overwrite !== "yes") {
+                console.log("- Skipped (file exists)");
+              } else {
+                await fs7.writeFile(ignorePath, ignoreContent, "utf-8");
+                writeActions.push({ kind: "rules", target: ignorePath, status: "updated" });
+                console.log(`- Updated ${ignorePath}`);
+              }
+            } else {
+              await fs7.writeFile(ignorePath, ignoreContent, "utf-8");
+              writeActions.push({ kind: "rules", target: ignorePath, status: "created" });
+              console.log(`- Created ${ignorePath}`);
+            }
+          } catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            console.log(`- Failed to create ignore file: ${message}`);
+          }
+        }
+      } else {
+        console.log("- Skipped. Add .contextstream/ignore to your projects as needed.");
+      }
+    } else {
+      console.log("- Using default exclusions only.");
+      console.log("  Tip: Create .contextstream/ignore in any project to customize.");
+    }
     if (scope === "global" || scope === "both") {
       console.log("\nInstalling global rules...");
       for (const editor of configuredEditors) {
@@ -20170,7 +21628,7 @@ Detected plan: ${planLabel} (graph: ${graphTierLabel})`);
         await rl.question(`Add current folder as a project? [Y/n] (${process.cwd()}): `)
       );
       if (addCwd.toLowerCase() !== "n" && addCwd.toLowerCase() !== "no") {
-        projectPaths.add(path7.resolve(process.cwd()));
+        projectPaths.add(path8.resolve(process.cwd()));
       }
       while (true) {
         console.log("\n  1) Add another project path");
@@ -20180,13 +21638,13 @@ Detected plan: ${planLabel} (graph: ${graphTierLabel})`);
         if (choice === "3") break;
         if (choice === "1") {
           const p = normalizeInput(await rl.question("Project folder path: "));
-          if (p) projectPaths.add(path7.resolve(p));
+          if (p) projectPaths.add(path8.resolve(p));
           continue;
         }
         if (choice === "2") {
           const parent = normalizeInput(await rl.question("Parent folder path: "));
           if (!parent) continue;
-          const parentAbs = path7.resolve(parent);
+          const parentAbs = path8.resolve(parent);
           const projects2 = await discoverProjectsUnderFolder(parentAbs);
           if (projects2.length === 0) {
             console.log(
@@ -20218,11 +21676,16 @@ Applying to ${projects.length} project(s)...`);
             folder_path: projectPath,
             workspace_id: workspaceId,
             workspace_name: workspaceName,
-            create_parent_mapping: createParentMapping
+            create_parent_mapping: createParentMapping,
+            // Include version and config info for desktop app compatibility
+            version: VERSION,
+            configured_editors: configuredEditors,
+            context_pack: contextPackEnabled,
+            api_url: apiUrl
           });
           writeActions.push({
             kind: "workspace-config",
-            target: path7.join(projectPath, ".contextstream", "config.json"),
+            target: path8.join(projectPath, ".contextstream", "config.json"),
             status: "created"
           });
           console.log(`- Linked workspace in ${projectPath}`);
@@ -20233,7 +21696,7 @@ Applying to ${projects.length} project(s)...`);
       } else if (workspaceId && workspaceId !== "dry-run" && workspaceName && dryRun) {
         writeActions.push({
           kind: "workspace-config",
-          target: path7.join(projectPath, ".contextstream", "config.json"),
+          target: path8.join(projectPath, ".contextstream", "config.json"),
           status: "dry-run"
         });
       }
@@ -20241,8 +21704,8 @@ Applying to ${projects.length} project(s)...`);
         for (const editor of configuredEditors) {
           try {
             if (editor === "cursor") {
-              const cursorPath = path7.join(projectPath, ".cursor", "mcp.json");
-              const vscodePath = path7.join(projectPath, ".vscode", "mcp.json");
+              const cursorPath = path8.join(projectPath, ".cursor", "mcp.json");
+              const vscodePath = path8.join(projectPath, ".vscode", "mcp.json");
               if (dryRun) {
                 writeActions.push({ kind: "mcp-config", target: cursorPath, status: "dry-run" });
                 writeActions.push({ kind: "mcp-config", target: vscodePath, status: "dry-run" });
@@ -20255,7 +21718,7 @@ Applying to ${projects.length} project(s)...`);
               continue;
             }
             if (editor === "claude") {
-              const mcpPath = path7.join(projectPath, ".mcp.json");
+              const mcpPath = path8.join(projectPath, ".mcp.json");
               if (dryRun) {
                 writeActions.push({ kind: "mcp-config", target: mcpPath, status: "dry-run" });
               } else {
@@ -20265,7 +21728,7 @@ Applying to ${projects.length} project(s)...`);
               continue;
             }
             if (editor === "kilo") {
-              const kiloPath = path7.join(projectPath, ".kilocode", "mcp.json");
+              const kiloPath = path8.join(projectPath, ".kilocode", "mcp.json");
               if (dryRun) {
                 writeActions.push({ kind: "mcp-config", target: kiloPath, status: "dry-run" });
               } else {
@@ -20275,7 +21738,7 @@ Applying to ${projects.length} project(s)...`);
               continue;
             }
             if (editor === "roo") {
-              const rooPath = path7.join(projectPath, ".roo", "mcp.json");
+              const rooPath = path8.join(projectPath, ".roo", "mcp.json");
               if (dryRun) {
                 writeActions.push({ kind: "mcp-config", target: rooPath, status: "dry-run" });
               } else {
@@ -20298,11 +21761,11 @@ Applying to ${projects.length} project(s)...`);
         const rule = generateRuleContent(editor, {
           workspaceName,
           workspaceId: workspaceId && workspaceId !== "dry-run" ? workspaceId : void 0,
-          projectName: path7.basename(projectPath),
+          projectName: path8.basename(projectPath),
           mode
         });
         if (!rule) continue;
-        const filePath = path7.join(projectPath, rule.filename);
+        const filePath = path8.join(projectPath, rule.filename);
         if (dryRun) {
           writeActions.push({ kind: "rules", target: filePath, status: "dry-run" });
           continue;
@@ -20335,6 +21798,7 @@ Applying to ${projects.length} project(s)...`);
       console.log(`Toolset: ${toolset} (${toolsetDesc})`);
       console.log(`Token reduction: ~75% compared to previous versions.`);
       console.log(`Context Pack: ${contextPackEnabled ? "enabled" : "disabled"}`);
+      console.log(`Response Timing: ${showTiming ? "enabled" : "disabled"}`);
     }
     console.log("\nNext steps:");
     console.log("- Restart your editor/CLI after changing MCP config or rules.");
@@ -20350,6 +21814,9 @@ Applying to ${projects.length} project(s)...`);
     console.log(
       "- Toggle Context Pack with CONTEXTSTREAM_CONTEXT_PACK=true|false (and in dashboard settings)."
     );
+    console.log(
+      "- Toggle Response Timing with CONTEXTSTREAM_SHOW_TIMING=true|false."
+    );
     console.log("");
     console.log("You're set up! Now try these prompts in your AI tool:");
     console.log('  1) "session summary"');
@@ -20365,8 +21832,8 @@ Applying to ${projects.length} project(s)...`);
 // src/index.ts
 var ENABLE_PROMPTS2 = (process.env.CONTEXTSTREAM_ENABLE_PROMPTS || "true").toLowerCase() !== "false";
 function showFirstRunMessage() {
-  const configDir = join9(homedir6(), ".contextstream");
-  const starShownFile = join9(configDir, ".star-shown");
+  const configDir = join10(homedir6(), ".contextstream");
+  const starShownFile = join10(configDir, ".star-shown");
   if (existsSync4(starShownFile)) {
     return;
   }