@intentic/claude-plugin 1.317.0

package/dist/session-start.mjs

@@ -0,0 +1,1658 @@
+import { createRequire as __intenticRequire } from 'node:module'; const require = __intenticRequire(import.meta.url);
+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 __commonJS = (cb, mod) => function __require() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+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/.pnpm/ignore@7.0.10/node_modules/ignore/index.js
+var require_ignore = __commonJS({
+  "../../node_modules/.pnpm/ignore@7.0.10/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_LITERAL_SPECIAL = /[.*+?()[\]{}^$|\\/]/;
+    var REGEX_TEST_BLANK_LINE = /^\uFEFF? *$/;
+    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 DOUBLE_SLASH = "//";
+    var SLASH_CODE = 47;
+    var DOT_CODE = 46;
+    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 RETURN_FALSE = () => false;
+    var cleanRangeBackSlash = (slashes) => {
+      const { length } = slashes;
+      return slashes.slice(0, length - length % 2);
+    };
+    var POSIX_CLASSES = {
+      alnum: "0-9A-Za-z",
+      alpha: "A-Za-z",
+      blank: " \\t",
+      cntrl: "\\x00-\\x1f\\x7f",
+      digit: "0-9",
+      graph: "!-.0-~",
+      lower: "a-z",
+      print: " -.0-~",
+      punct: "!-.:-@\\[-`{-~",
+      // git's `sane-ctype.h` classifies \v and \f as control, not space,
+      //   unlike C's `isspace`
+      space: " \\t\\n\\r",
+      upper: "A-Z",
+      xdigit: "0-9A-Fa-f"
+    };
+    var CLASS_MEMBERS_TO_ESCAPE = "\\]^-[";
+    var escapeMember = (char) => CLASS_MEMBERS_TO_ESCAPE.indexOf(char) < 0 ? char : ESCAPE + char;
+    var NON_SLASH = "(?!\\/)";
+    var classSource = (negated, body) => {
+      if (negated) {
+        return `[^\\/${body}]`;
+      }
+      const source = `[${body}]`;
+      return new RegExp(source).test("/") ? NON_SLASH + source : source;
+    };
+    var scanBracket = (pattern, start) => {
+      const { length } = pattern;
+      let index = start + 1;
+      let negated = EMPTY;
+      const lead = pattern[index];
+      if (lead === "!" || lead === "^") {
+        negated = "^";
+        index++;
+      }
+      let body = EMPTY;
+      let prev = EMPTY;
+      for (; ; ) {
+        const char = pattern[index];
+        if (char === UNDEFINED) {
+          return null;
+        }
+        if (char === ESCAPE) {
+          const escaped = pattern[index + 1];
+          if (escaped === UNDEFINED) {
+            return null;
+          }
+          body += escapeMember(escaped);
+          prev = escaped;
+          index++;
+        } else if (char === "-" && prev && index + 1 < length && pattern[index + 1] !== "]") {
+          index++;
+          let to = pattern[index];
+          if (to === ESCAPE) {
+            to = pattern[index += 1];
+          }
+          if (prev <= to) {
+            body += `-${escapeMember(to)}`;
+          }
+          prev = EMPTY;
+        } else if (char === "[" && pattern[index + 1] === ":") {
+          const nameStart = index + 2;
+          let end = nameStart;
+          while (end < length && pattern[end] !== "]") {
+            end++;
+          }
+          if (end === length) {
+            return null;
+          }
+          if (end > nameStart && pattern[end - 1] === ":") {
+            const expanded = POSIX_CLASSES[pattern.slice(nameStart, end - 1)];
+            if (expanded === UNDEFINED) {
+              return null;
+            }
+            body += expanded;
+            prev = EMPTY;
+            index = end;
+          } else {
+            body += escapeMember("[");
+            prev = "[";
+            index = nameStart - 2;
+          }
+        } else {
+          body += escapeMember(char);
+          prev = char;
+        }
+        index++;
+        if (pattern[index] === "]") {
+          return {
+            end: index,
+            source: classSource(negated, body)
+          };
+        }
+      }
+    };
+    var NEVER_MATCH = "[]";
+    var PLACEHOLDER = "\0";
+    var REGEX_RESTORE_PLACEHOLDER = new RegExp(
+      `${PLACEHOLDER}(\\d+)${PLACEHOLDER}`,
+      "g"
+    );
+    var TRAILING_WILDCARD = "\uE000";
+    var extractBrackets = (pattern) => {
+      const sources = [];
+      const hold = (source) => `${PLACEHOLDER}${sources.push(source) - 1}${PLACEHOLDER}`;
+      const { length } = pattern;
+      let out = EMPTY;
+      let index = 0;
+      while (index < length) {
+        const char = pattern[index];
+        if (char === ESCAPE) {
+          const escaped = pattern[index + 1];
+          if (escaped === "*" || escaped === "[" || escaped === SPACE || escaped === ESCAPE) {
+            out += pattern.slice(index, index + 2);
+          } else {
+            out += hold(
+              REGEX_LITERAL_SPECIAL.test(escaped) ? ESCAPE + escaped : escaped
+            );
+          }
+          index += 2;
+        } else if (char === PLACEHOLDER) {
+          out += hold(`[${PLACEHOLDER}]`);
+          index++;
+        } else if (char === "[") {
+          const scanned = scanBracket(pattern, index);
+          if (scanned === null) {
+            out += hold(NEVER_MATCH);
+            index = length;
+          } else {
+            out += hold(scanned.source);
+            index = scanned.end + 1;
+          }
+        } else {
+          out += char;
+          index++;
+        }
+      }
+      return {
+        source: out,
+        sources
+      };
+    };
+    var DIRECT = null;
+    var REGEX_INNER_SLASH = /\/(?!$)/;
+    var REPLACERS = [
+      [
+        // Remove BOM
+        // TODO:
+        // Other similar zero-width characters?
+        /^\uFEFF/,
+        () => EMPTY,
+        "\uFEFF"
+      ],
+      [
+        // A trailing line terminator, left on when a whole file's contents are
+        //   added as one pattern rather than split into lines. git never sees one
+        //   -- it reads a `.gitignore` line by line -- so it is not part of the
+        //   pattern and is dropped here, apart from the trailing-space trimming,
+        //   which follows git in touching spaces and nothing else.
+        /[\r\n]+$/,
+        () => EMPTY
+      ],
+      // > Trailing spaces are ignored unless they are quoted with backslash ("\")
+      [
+        // Only spaces, never tabs or other whitespace: git trims a trailing run
+        //   of `' '` and nothing else (dir.c, `trim_trailing_spaces`, a single
+        //   `case ' '`), so a pattern ending in a tab keeps it as a literal.
+        // (a\ ) -> (a )
+        // (a  ) -> (a)
+        // (a ) -> (a)
+        // (a \ ) -> (a  )
+        /((?:\\\\)*?)(\\? +)$/,
+        (_, m1, m2) => m1 + (m2.indexOf("\\") === 0 ? SPACE : EMPTY)
+      ],
+      // Replace (\ ) with ' '
+      // Only a space: an escaped tab or other whitespace is already a literal by
+      //   the time it reaches here, and a bare tab must be left as one, not turned
+      //   into a space.
+      // (\ ) -> ' '
+      // (\\ ) -> '\\ '
+      // (\\\ ) -> '\\ '
+      [
+        /(\\+?) /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
+        /^\//,
+        () => "^",
+        SLASH
+      ],
+      // replace special metacharacter slash after the leading slash
+      [
+        /\//g,
+        () => "\\/",
+        SLASH
+      ],
+      [
+        // > 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
+        DIRECT,
+        (source, pattern) => {
+          if (!source || source[0] === "^") {
+            return source;
+          }
+          const anchor = !REGEX_INNER_SLASH.test(pattern) ? "(?:^|\\/)" : "^";
+          return anchor + source;
+        }
+      ],
+      // 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 ? str.slice(index + 6) === "\\/" ? "(?:\\/[^\\/]+)+" : "(?:\\/[^\\/]+)*" : "\\/.+",
+        "*"
+      ],
+      // 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;
+        },
+        "*"
+      ],
+      // trailing wildcard, held apart from a literal star
+      [
+        // The step above leaves a trailing `*` alone, so a single `\*` is all that
+        //   can be left at the end here. Whether it is a wildcard or a literal
+        //   turns on the backslashes the user put in front of it: the escaper has
+        //   since doubled every one, so what stands here is those `2N` doubled
+        //   backslashes and then the star's own escape. An even number of the
+        //   original `N` leaves the star unescaped -- a wildcard -- and an odd
+        //   number escapes it -- a literal. This runs while the two are still
+        //   distinct, before the unescape steps below collapse the literal onto
+        //   the very `\*` a wildcard leaves behind.
+        /(^|[^\\])((?:\\\\)*)\\\*$/,
+        (match, p1, p2) => (
+          // `p2` holds the doubled user backslashes; half of them is `N`.
+          p2.length / 2 % 2 === 0 ? p1 + p2 + TRAILING_WILDCARD : match
+        ),
+        "*"
+      ],
+      [
+        // unescape, revert step 3 except for back slash
+        // For example, if a user escape a '\\*',
+        // after step 3, the result will be '\\\\\\*'
+        /\\\\\\(?=[$.|*+(){^])/g,
+        () => ESCAPE,
+        ESCAPE + ESCAPE
+      ],
+      [
+        // '\\\\' -> '\\'
+        /\\\\/g,
+        () => ESCAPE,
+        ESCAPE + ESCAPE
+      ],
+      [
+        // Every real bracket expression -- POSIX classes included -- has already
+        //   been held aside by `extractBrackets`, so the only `[` left in the
+        //   pattern is an escaped, literal one.
+        // `\` is escaped by step 3
+        /\\\[([^\]/]*?)(\\*)($|\])/g,
+        // '\\[bar]' -> '\\\\[bar\\]'
+        (match, range, endEscape, close) => `\\[${range}${cleanRangeBackSlash(endEscape)}${close}`,
+        "["
+      ],
+      // ending
+      [
+        // 'js' will not match 'js.'
+        // 'ab' will not match 'abc'
+        DIRECT,
+        // 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/'
+        (source) => {
+          const last = source[source.length - 1];
+          if (!last || last === TRAILING_WILDCARD) {
+            return source;
+          }
+          return last === SLASH ? `${source}$` : `${source}(?=$|\\/$)`;
+        }
+      ]
+    ];
+    var REGEX_REPLACE_TRAILING_WILDCARD = /(^|\\\/)?\uE000$/;
+    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 WILDCARD = "[^\\/]*";
+    var separatorAfter = (run, at) => {
+      let separator = EMPTY;
+      for (let index = at + 1; index < run.length && !run[index].wildcard; index++) {
+        separator += run[index].single;
+      }
+      return separator;
+    };
+    var pinWildcards = (source) => {
+      if (source.indexOf(WILDCARD) < 0) {
+        return source;
+      }
+      const tokens = [];
+      const { length } = source;
+      let index = 0;
+      while (index < length) {
+        const char = source[index];
+        if (source.startsWith(WILDCARD, index)) {
+          tokens.push({ wildcard: true });
+          index += WILDCARD.length;
+        } else if (char === "[") {
+          let end = index + 1;
+          if (source[end] === "^") {
+            end++;
+          }
+          if (source[end] === "]") {
+            end++;
+          }
+          while (end < length && source[end] !== "]") {
+            end += source[end] === ESCAPE ? 2 : 1;
+          }
+          end++;
+          tokens.push({ single: source.slice(index, end) });
+          index = end;
+        } else if (char === ESCAPE) {
+          tokens.push({ single: source.slice(index, index + 2) });
+          index += 2;
+        } else if (char === "(") {
+          let depth = 0;
+          let end = index;
+          do {
+            if (source[end] === ESCAPE) {
+              end++;
+            } else if (source[end] === "(") {
+              depth++;
+            } else if (source[end] === ")") {
+              depth--;
+            }
+            end++;
+          } while (end < length && depth > 0);
+          if ("*+?".indexOf(source[end]) >= 0) {
+            end++;
+          }
+          tokens.push({ boundary: source.slice(index, end) });
+          index = end;
+        } else if (char === "^" || char === "$") {
+          tokens.push({ boundary: char });
+          index++;
+        } else {
+          tokens.push({ single: char });
+          index++;
+        }
+      }
+      let out = EMPTY;
+      let run = [];
+      const flush = () => {
+        let lastWildcard;
+        run.forEach((token, at) => {
+          if (token.wildcard) {
+            lastWildcard = at;
+          }
+        });
+        run.forEach((token, at) => {
+          if (!token.wildcard) {
+            out += token.single;
+            return;
+          }
+          out += at === lastWildcard ? WILDCARD : `(?:(?!${separatorAfter(run, at)})[^\\/])*`;
+        });
+        run = [];
+      };
+      tokens.forEach((token) => {
+        if (token.boundary === void 0) {
+          run.push(token);
+          return;
+        }
+        flush();
+        out += token.boundary;
+      });
+      flush();
+      return out;
+    };
+    var makeRegexPrefix = (pattern) => {
+      const { source, sources } = extractBrackets(pattern);
+      const replaced = REPLACERS.reduce(
+        // A pass whose matcher finds nothing hands back the very string it was
+        //   given, so asking first costs a search and saves a rewrite. Ten of the
+        //   fifteen passes never fire for a typical .gitignore line, and between
+        //   them they were 45% of this chain.
+        (prev, [matcher, replacer, required]) => {
+          if (matcher === DIRECT) {
+            return replacer(prev, pattern);
+          }
+          if (required !== UNDEFINED && prev.indexOf(required) < 0) {
+            return prev;
+          }
+          return matcher.test(prev) ? prev.replace(matcher, replacer.bind(pattern)) : prev;
+        },
+        source
+      );
+      return sources.length ? replaced.replace(
+        REGEX_RESTORE_PLACEHOLDER,
+        (match, index) => sources[index]
+      ) : replaced;
+    };
+    var matchesBasename = (body) => {
+      const index = body.indexOf(SLASH);
+      return index < 0 || index === body.length - 1;
+    };
+    var basenameOf = (path) => {
+      const end = path.length - 1;
+      const index = path.lastIndexOf(
+        SLASH,
+        path[end] === SLASH ? end - 1 : end
+      );
+      return index < 0 ? path : path.slice(index + 1);
+    };
+    var parentOf = (path) => {
+      if (path.charCodeAt(0) === SLASH_CODE || path.indexOf(DOUBLE_SLASH) >= 0) {
+        const slices = path.split(SLASH).filter(Boolean);
+        slices.pop();
+        return slices.length ? slices.join(SLASH) + SLASH : EMPTY;
+      }
+      const end = path.length - 1;
+      const cut = path.lastIndexOf(
+        SLASH,
+        path.charCodeAt(end) === SLASH_CODE ? end - 1 : end
+      );
+      return cut < 0 ? EMPTY : path.slice(0, cut + 1);
+    };
+    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);
+      }
+      // Worked out on first use and kept behind an own property, the way `regex`
+      //   caches itself in `_regex`. Deciding it in the constructor instead would
+      //   add a fourth `defineProperty` to every rule ever built, which cost 4% of
+      //   every compile -- including the compiles of rules that are never matched
+      //   against anything.
+      get _basenameOnly() {
+        return define(this, "_basenameOnly", matchesBasename(this.body));
+      }
+      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 = pinWildcards(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 = [];
+        this._basenameCount = 0;
+      }
+      _add(pattern) {
+        if (pattern && pattern[KEY_IGNORE]) {
+          this._rules = this._rules.concat(pattern._rules._rules);
+          this._basenameCount += pattern._rules._basenameCount;
+          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);
+          if (matchesBasename(rule.body)) {
+            this._basenameCount++;
+          }
+        }
+      }
+      // @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(path, checkUnignored, mode) {
+        let ignored = false;
+        let unignored = false;
+        let matchedRule;
+        const rules = this._rules;
+        const { length } = rules;
+        const shortcut = this._basenameCount * 2 >= length;
+        const basename2 = shortcut ? basenameOf(path) : path;
+        for (let index = 0; index < length; index++) {
+          const rule = rules[index];
+          const { negative } = rule;
+          const skip = unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored;
+          if (!skip && rule[mode].test(
+            shortcut && rule._basenameOnly ? basename2 : path
+          )) {
+            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 = (path, originalPath, doThrow) => {
+      if (!isString(path)) {
+        return doThrow(
+          `path must be a string, but got \`${originalPath}\``,
+          TypeError
+        );
+      }
+      if (!path) {
+        return doThrow(`path must not be empty`, TypeError);
+      }
+      if (checkPath.isNotRelative(path)) {
+        const r = "`path.relative()`d";
+        return doThrow(
+          `path should be a ${r} string, but got "${originalPath}"`,
+          RangeError
+        );
+      }
+      return true;
+    };
+    var isNotRelative = (path) => {
+      const first = path.charCodeAt(0);
+      if (first === SLASH_CODE) {
+        return true;
+      }
+      if (first !== DOT_CODE) {
+        return false;
+      }
+      if (path.length === 1) {
+        return true;
+      }
+      const second = path.charCodeAt(1);
+      if (second === SLASH_CODE) {
+        return true;
+      }
+      if (second !== DOT_CODE) {
+        return false;
+      }
+      return path.length === 2 || path.charCodeAt(2) === SLASH_CODE;
+    };
+    checkPath.isNotRelative = isNotRelative;
+    checkPath.convert = (p) => p;
+    var Ignore = 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, cache2, checkUnignored) {
+        const path = originalPath && checkPath.convert(originalPath);
+        checkPath(
+          path,
+          originalPath,
+          this._strictPathCheck ? throwError : RETURN_FALSE
+        );
+        return this._t(path, cache2, checkUnignored);
+      }
+      checkIgnore(path) {
+        if (path.charCodeAt(path.length - 1) !== SLASH_CODE) {
+          return this.test(path);
+        }
+        const parentPath = parentOf(path);
+        if (parentPath) {
+          const parent = this._t(parentPath, this._testCache, true);
+          if (parent.ignored) {
+            return parent;
+          }
+        }
+        return this._rules.test(path, false, MODE_CHECK_IGNORE);
+      }
+      _t(path, cache2, checkUnignored) {
+        if (path in cache2) {
+          return cache2[path];
+        }
+        const parentPath = parentOf(path);
+        const parent = parentPath ? this._t(parentPath, cache2, checkUnignored) : UNDEFINED;
+        return cache2[path] = parent && parent.ignored ? parent : this._rules.test(path, checkUnignored, MODE_IGNORE);
+      }
+      ignores(path) {
+        return this._test(path, this._ignoreCache, false).ignored;
+      }
+      createFilter() {
+        return (path) => !this.ignores(path);
+      }
+      filter(paths) {
+        return makeArray(paths).filter(this.createFilter());
+      }
+      // @returns {TestResult}
+      test(path) {
+        return this._test(path, this._testCache, true);
+      }
+    };
+    var factory = (options) => new Ignore(options);
+    var isPathValid = (path) => checkPath(path && checkPath.convert(path), path, 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 = (path) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path) || isNotRelative(path);
+    };
+    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/session-start.ts
+import { appendFileSync as appendFileSync2, existsSync } from "node:fs";
+import { join as join7 } from "node:path";
+
+// ../agent-context/src/field-notes.ts
+import { createHash } from "node:crypto";
+import { readFileSync, statSync } from "node:fs";
+var FIELD_NOTES_NOTE_TITLE = "Field notes for this sandbox";
+var FIELD_NOTES_NOTE_HEADER = `## ${FIELD_NOTES_NOTE_TITLE}`;
+var ALWAYS = ["meta"];
+var ROW = /^(\d+),([a-z][a-z0-9_-]*),/;
+var TOP_LEVEL = /^([a-z][a-z0-9_]*)(\[|:)/;
+var blocksOf = (lines) => {
+  const opens = [];
+  for (const [at, line] of lines.entries()) {
+    const key = TOP_LEVEL.exec(line)?.[1];
+    if (key !== void 0) {
+      opens.push({ key, at });
+    }
+  }
+  const blocks = /* @__PURE__ */ new Map();
+  for (const [index, open] of opens.entries()) {
+    blocks.set(open.key, lines.slice(open.at, opens[index + 1]?.at).join("\n").trimEnd());
+  }
+  return blocks;
+};
+var indexOf = (block) => {
+  if (block === void 0) {
+    return void 0;
+  }
+  const rows = [];
+  for (const line of block.split("\n").slice(1)) {
+    const trimmed = line.trim();
+    if (trimmed === "") {
+      continue;
+    }
+    const row = ROW.exec(trimmed);
+    if (row?.[1] === void 0 || row[2] === void 0) {
+      return void 0;
+    }
+    rows.push({ rank: Number(row[1]), id: row[2] });
+  }
+  return rows.length === 0 ? void 0 : rows.toSorted((left, right) => left.rank - right.rank);
+};
+var withinBudget = (sections, spent, budget) => {
+  const kept = [];
+  let used = spent;
+  for (const section of sections) {
+    const cost = section.text.length + 1;
+    if (used + cost > budget) {
+      break;
+    }
+    used += cost;
+    kept.push(section);
+  }
+  return kept;
+};
+var readFieldNotesFile = (file) => {
+  try {
+    const text = readFileSync(file, "utf8");
+    return text.trim() === "" ? void 0 : { text, writtenAt: statSync(file).mtimeMs };
+  } catch {
+    return void 0;
+  }
+};
+var fieldNotes = ({ file: path, budget, onUnreadable, title = FIELD_NOTES_NOTE_TITLE }) => {
+  const file = readFieldNotesFile(path);
+  if (file === void 0) {
+    return void 0;
+  }
+  const lines = file.text.split("\n");
+  const blocks = blocksOf(lines);
+  const index = indexOf(blocks.get("priority"));
+  if (index === void 0) {
+    onUnreadable?.(`no readable \`priority\` table, so there is no order to send it in`);
+    return void 0;
+  }
+  const missing = index.filter(({ id }) => !blocks.has(id)).map(({ id }) => id);
+  if (missing.length > 0) {
+    onUnreadable?.(`the index names sections the file does not carry: ${missing.join(", ")}`);
+    return void 0;
+  }
+  const head = ALWAYS.flatMap((key) => {
+    const block = blocks.get(key);
+    return block === void 0 ? [] : [block];
+  });
+  const ranked = index.flatMap(({ id, rank }) => {
+    const text2 = blocks.get(id);
+    return text2 === void 0 ? [] : [{ id, rank, text: text2 }];
+  });
+  const header = `## ${title}`;
+  const spent = header.length + head.reduce((sum, block) => sum + block.length + 1, 0);
+  const kept = withinBudget(ranked, spent, budget);
+  const dropped = ranked.filter((section) => !kept.includes(section));
+  const disclosure = dropped.length === 0 ? `# every section of ${path} is below.` : `# ranks ${kept.length + 1}-${ranked.length} of ${path} are NOT below (${dropped.map((section) => section.id).join(", ")}); read the file itself if a turn needs them.`;
+  const text = [header, "", disclosure, ...head, ...kept.map((section) => section.text)].join("\n");
+  return {
+    text,
+    chars: text.length,
+    revision: createHash("sha256").update(file.text).digest("hex").slice(0, 8),
+    ranksSent: kept.length,
+    ranksTotal: ranked.length,
+    writtenAt: file.writtenAt
+  };
+};
+
+// ../agent-context/src/workspace-map.ts
+import { readdirSync, readFileSync as readFileSync2, statSync as statSync2 } from "node:fs";
+import { basename, dirname, join, relative, sep } from "node:path";
+
+// ../../_shared/workspace-ignore/src/index.ts
+var import_ignore = __toESM(require_ignore(), 1);
+
+// ../../_tools/constants/src/hosted-tiers.ts
+var HOSTED_TIERS = [
+  { id: "free", name: "Free", cpuKind: "shared", cpus: 4, memoryMb: 4096, volumeGb: 10, monthlyHours: 40, priceUsd: 0, flyHourUsd: 0.0329 },
+  { id: "standard", name: "Standard", cpuKind: "shared", cpus: 8, memoryMb: 8192, volumeGb: 25, monthlyHours: 220, priceUsd: 20, flyHourUsd: 0.0657 },
+  { id: "max", name: "Max", cpuKind: "shared", cpus: 8, memoryMb: 16384, volumeGb: 50, monthlyHours: 320, priceUsd: 50, flyHourUsd: 0.1234 }
+];
+var FREE_TIER = HOSTED_TIERS[0];
+var PAID_TIERS = HOSTED_TIERS.filter((tier) => tier.priceUsd > 0);
+
+// ../../_tools/constants/src/index.ts
+var REFERENCE_DIR = "refs";
+var PUBLIC_DIR = "public";
+var GOOGLE_CLIENT_ID = "481795963975-cq9msl6higcd91joidrfp8mjlkuq5fk3.apps.googleusercontent.com";
+var GOOGLE_TOKEN_STORAGE_KEY = `intentic.gid.${GOOGLE_CLIENT_ID}`;
+
+// ../../_shared/workspace-ignore/src/constants.ts
+var GIT_DIR = ".git";
+var IGNORED_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  GIT_DIR,
+  ".tmp",
+  "dist",
+  ".cache",
+  ".turbo",
+  ".next",
+  ".angular",
+  ".pnpm-store",
+  ".yarn",
+  ".venv",
+  "venv",
+  "__pycache__",
+  ".pytest_cache",
+  ".mypy_cache",
+  ".ruff_cache",
+  ".gradle"
+]);
+var isSeparator = (char) => char === "/" || char === "\\";
+var firstSegment = (relPath) => {
+  let start = 0;
+  while (isSeparator(relPath[start])) {
+    start++;
+  }
+  let end = start;
+  while (end < relPath.length && !isSeparator(relPath[end])) {
+    end++;
+  }
+  return relPath.slice(start, end);
+};
+var isReferencePath = (relPath) => firstSegment(relPath) === REFERENCE_DIR;
+var isPublicPath = (relPath) => firstSegment(relPath) === PUBLIC_DIR;
+
+// ../agent-context/src/workspace-map.ts
+var WORKSPACE_MAP_NOTE_HEADER = "## Map of this project";
+var MAX_NOTE_CHARS = 2800;
+var MAX_PURPOSE_CHARS = 100;
+var MAX_AREA_DEPTH = 4;
+var MAX_AREA_ENTRIES = 4e3;
+var MAX_AREAS = 24;
+var CONTAINER_MIN_CHILDREN = 3;
+var DOMINANT_SHARE = 0.5;
+var MAX_EXPANDED = 12;
+var MANIFESTS = ["package.json", "pyproject.toml", "Cargo.toml", "composer.json", "go.mod", "build.gradle", "pom.xml"];
+var posix = (path) => path.split(sep).join("/");
+var isBrowsable = (name, relPath) => !name.startsWith(".") && !IGNORED_DIRS.has(name) && !isReferencePath(relPath) && !isPublicPath(relPath);
+var childDirs = (dir, root) => {
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  return entries.filter((entry) => entry.isDirectory() && isBrowsable(entry.name, posix(relative(root, join(dir, entry.name))))).map((entry) => entry.name).toSorted();
+};
+var readIfPresent = (path) => {
+  try {
+    return readFileSync2(path, "utf8");
+  } catch {
+    return void 0;
+  }
+};
+var hasManifest = (dir) => MANIFESTS.some((name) => readIfPresent(join(dir, name)) !== void 0);
+var describeManifest = (dir, name) => {
+  const source = readIfPresent(join(dir, name));
+  if (source === void 0) {
+    return void 0;
+  }
+  if (name.endsWith(".json")) {
+    try {
+      const description = JSON.parse(source).description;
+      return typeof description === "string" && description.trim() !== "" ? description.trim() : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  if (name === "go.mod") {
+    const module = /^\s*module\s+(\S+)/m.exec(source)?.[1];
+    return module === void 0 ? void 0 : `Go module ${module.split("/").slice(-2).join("/")}`;
+  }
+  const toml = /^\s*description\s*=\s*["'](.+?)["']\s*$/m.exec(source)?.[1];
+  const xml = /<description>([^<]+)<\/description>/.exec(source)?.[1];
+  const found = (toml ?? xml)?.trim();
+  return found === void 0 || found === "" ? void 0 : found;
+};
+var describeReadme = (dir) => {
+  const source = readIfPresent(join(dir, "README.md")) ?? readIfPresent(join(dir, "readme.md"));
+  if (source === void 0) {
+    return void 0;
+  }
+  const body = source.replace(/^---[\s\S]*?\n---\s*/, "");
+  for (const raw of body.split("\n")) {
+    const line = raw.trim();
+    if (line === "" || line.startsWith("#") || line.startsWith("<") || line.startsWith(">") || line.startsWith("|")) {
+      continue;
+    }
+    const prose = line.replace(/!\[[^\]]*\]\([^)]*\)/g, "").replace(/\[([^\]]*)\]\([^)]*\)/g, "$1").replace(/[*_`]/g, "").trim();
+    if (prose === "" || prose.startsWith("-") || prose.startsWith("*")) {
+      continue;
+    }
+    return prose;
+  }
+  return void 0;
+};
+var clip = (text, max) => {
+  const oneLine = text.replace(/\s+/g, " ").trim();
+  if (oneLine.length <= max) {
+    return oneLine;
+  }
+  const head = oneLine.slice(0, max);
+  const lastSpace = head.lastIndexOf(" ");
+  return `${(lastSpace > max / 2 ? head.slice(0, lastSpace) : head).replace(/[.,;:]$/, "")}\u2026`;
+};
+var purposeOf = (dir) => {
+  for (const name of MANIFESTS) {
+    const described = describeManifest(dir, name);
+    if (described !== void 0) {
+      return clip(described, MAX_PURPOSE_CHARS);
+    }
+  }
+  const readme = describeReadme(dir);
+  return readme === void 0 ? "" : clip(readme, MAX_PURPOSE_CHARS);
+};
+var measure = (dir, root) => {
+  const extensions = /* @__PURE__ */ new Map();
+  let files = 0;
+  let visited = 0;
+  const walk = (current, depth) => {
+    if (depth > MAX_AREA_DEPTH || visited >= MAX_AREA_ENTRIES) {
+      return;
+    }
+    let entries;
+    try {
+      entries = readdirSync(current, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (visited >= MAX_AREA_ENTRIES) {
+        return;
+      }
+      visited += 1;
+      const child = join(current, entry.name);
+      if (entry.isDirectory()) {
+        if (isBrowsable(entry.name, posix(relative(root, child)))) {
+          walk(child, depth + 1);
+        }
+        continue;
+      }
+      if (!entry.isFile() || entry.name.startsWith(".")) {
+        continue;
+      }
+      files += 1;
+      const dot = entry.name.lastIndexOf(".");
+      if (dot > 0) {
+        const ext = entry.name.slice(dot + 1).toLowerCase();
+        if (ext.length <= 5) {
+          extensions.set(ext, (extensions.get(ext) ?? 0) + 1);
+        }
+      }
+    }
+  };
+  walk(dir, 0);
+  const kinds = [...extensions.entries()].toSorted((left, right) => right[1] - left[1] || left[0].localeCompare(right[0])).slice(0, 2).map(([ext]) => ext);
+  return { files, kinds };
+};
+var projectRootOf = (root, cwd) => {
+  let current = cwd;
+  for (; ; ) {
+    try {
+      statSync2(join(current, ".git"));
+      return current;
+    } catch {
+    }
+    if (current === root || current === dirname(current)) {
+      return root;
+    }
+    const parent = dirname(current);
+    if (relative(root, parent).startsWith("..")) {
+      return root;
+    }
+    current = parent;
+  }
+};
+var packagesIn = (dir, root) => {
+  if (hasManifest(dir)) {
+    return [];
+  }
+  const children = childDirs(dir, root);
+  const bearing = children.filter((child) => hasManifest(join(dir, child)));
+  return children.length >= CONTAINER_MIN_CHILDREN && bearing.length >= CONTAINER_MIN_CHILDREN ? bearing.map((child) => ({ name: child, dir: join(dir, child) })) : [];
+};
+var areaDirsOf = (projectRoot, root) => {
+  const names = childDirs(projectRoot, root);
+  const areas = names.map((name) => {
+    const dir = join(projectRoot, name);
+    return { name, dir, packages: packagesIn(dir, root) };
+  });
+  const shelf = areas.length <= 2 ? areas.find((area) => area.packages.length > 0) : void 0;
+  return shelf === void 0 ? areas : shelf.packages.map((entry) => ({ name: `${shelf.name}/${entry.name}`, dir: entry.dir, packages: [] }));
+};
+var workspaceMapOf = ({ root, cwd }) => {
+  const projectRoot = projectRootOf(root, cwd);
+  const found = areaDirsOf(projectRoot, root);
+  if (found.length < 2) {
+    return void 0;
+  }
+  const cwdRel = posix(relative(projectRoot, cwd));
+  const isHere = (name) => cwdRel === name || cwdRel.startsWith(`${name}/`);
+  const asArea = (name, dir, packages, children) => {
+    const { files, kinds } = measure(dir, root);
+    return { name, files, kinds, purpose: purposeOf(dir), here: isHere(name), packages, children, childrenOmitted: 0 };
+  };
+  const expand = (parent, entries) => {
+    const ranked2 = entries.map((entry) => asArea(`${parent}/${entry.name}`, entry.dir, packagesIn(entry.dir, root).length, [])).toSorted((left, right) => right.files - left.files || left.name.localeCompare(right.name));
+    return { children: ranked2.slice(0, MAX_EXPANDED), childrenOmitted: Math.max(0, ranked2.length - MAX_EXPANDED) };
+  };
+  const base = found.map((area) => ({ ...area, measured: asArea(area.name, area.dir, area.packages.length, []) }));
+  const total = base.reduce((sum, entry) => sum + entry.measured.files, 0);
+  const biggest = base.toSorted((left, right) => right.measured.files - left.measured.files)[0];
+  const dominant = cwdRel === "" && biggest !== void 0 && biggest.measured.files >= total * DOMINANT_SHARE ? biggest.name : void 0;
+  const measured = base.map(({ name, dir, packages, measured: area }) => {
+    if (isHere(name)) {
+      return { ...area, ...expand(name, packages) };
+    }
+    return name === dominant ? { ...area, ...expand(name, areaDirsOf(dir, root)) } : area;
+  });
+  const ranked = measured.toSorted((left, right) => right.files - left.files || left.name.localeCompare(right.name));
+  const kept = ranked.slice(0, MAX_AREAS);
+  const here = ranked.slice(MAX_AREAS).filter((area) => area.here);
+  const areas = [...kept, ...here];
+  return {
+    project: posix(relative(root, projectRoot)),
+    cwd: posix(relative(root, cwd)),
+    areas,
+    omitted: ranked.length - areas.length,
+    // Only meaningful when the project isn't the whole workspace: names what else is there, nothing more.
+    siblings: projectRoot === root ? [] : childDirs(root, root).filter((name) => name !== basename(projectRoot))
+  };
+};
+var sizeOf = (area) => `${area.files} file${area.files === 1 ? "" : "s"}${area.kinds.length > 0 ? ` \xB7 ${area.kinds.join(", ")}` : ""}${area.packages > 0 ? ` \xB7 ${area.packages} packages` : ""}`;
+var areaLine = (area, width, indent) => `${indent}${area.name.padEnd(width - indent.length)}  ${sizeOf(area)}${area.here && area.children.length === 0 ? "  \u2190 you are here" : ""}`;
+var areaBlock = (area, width, silent) => [
+  areaLine(area, width, "  "),
+  ...area.purpose === "" || silent.has(area.name) ? [] : [`  ${" ".repeat(width - 2)}  ${area.purpose}`],
+  ...area.children.flatMap((child) => [
+    areaLine(child, width, "      "),
+    ...child.purpose === "" || silent.has(child.name) ? [] : [`      ${" ".repeat(width - 6)}  ${child.purpose}`]
+  ]),
+  // What opening this area left out; unsaid, it reads as if that were the whole list.
+  ...area.childrenOmitted > 0 ? [`      \u2026 and ${area.childrenOmitted} more in ${area.name}`] : []
+];
+var render = (map, exactPaths) => {
+  const project = map.project === "" ? "the workspace" : `\`${map.project}\``;
+  const all = map.areas.flatMap((area) => [area, ...area.children]);
+  const width = Math.min(
+    Math.max(...map.areas.flatMap((area) => [area.name.length + 2, ...area.children.map((child) => child.name.length + 6)])) + 2,
+    34
+  );
+  const head = [
+    WORKSPACE_MAP_NOTE_HEADER,
+    "",
+    `This is current filesystem context. It maps project areas, not file locations; use ${exactPaths} for exact paths.`,
+    "Do not `ls` or `tree` the workspace root to orient yourself \u2014 the map above is that orientation.",
+    "",
+    map.cwd === map.project ? `You are at the top of ${project}.` : `You are here: \`${map.cwd}\``,
+    "",
+    `${project}, ${map.areas.length} area${map.areas.length === 1 ? "" : "s"}${map.omitted > 0 ? `, plus ${map.omitted} smaller ones not listed` : ""}`
+  ];
+  const tail = map.siblings.length > 0 ? ["", `Also under the workspace root: ${map.siblings.map((name) => `${name}/`).join(", ")}`] : [];
+  const byFilesAsc = all.toSorted((left, right) => left.files - right.files).map((area) => area.name);
+  for (let muted = 0; muted <= byFilesAsc.length; muted += 1) {
+    const silent2 = new Set(byFilesAsc.slice(0, muted));
+    const note = [...head, ...map.areas.flatMap((area) => areaBlock(area, width, silent2)), ...tail].join("\n");
+    if (note.length <= MAX_NOTE_CHARS) {
+      return note;
+    }
+  }
+  const silent = new Set(byFilesAsc);
+  const lines = [];
+  let used = [...head, ...tail].join("\n").length;
+  let dropped = 0;
+  for (const area of map.areas) {
+    const block = areaBlock(area, width, silent);
+    const cost = block.reduce((sum, line) => sum + line.length + 1, 0);
+    if (used + cost > MAX_NOTE_CHARS) {
+      dropped += 1;
+      continue;
+    }
+    used += cost;
+    lines.push(...block);
+  }
+  const total = map.omitted + dropped;
+  return [...head, ...lines, ...total > 0 ? [`  \u2026 and ${total} more`] : [], ...tail].join("\n");
+};
+var TTL_MS = 6e4;
+var cache = /* @__PURE__ */ new Map();
+var workspaceMapNote = (input) => {
+  const exactPaths = input.exactPaths ?? "`iq files` or Read";
+  const key = `${input.root}\0${input.cwd}\0${exactPaths}`;
+  const hit = cache.get(key);
+  if (hit !== void 0 && Date.now() - hit.at < TTL_MS) {
+    return hit.note;
+  }
+  let note;
+  try {
+    const map = workspaceMapOf(input);
+    note = map === void 0 ? void 0 : render(map, exactPaths);
+  } catch {
+    note = void 0;
+  }
+  cache.set(key, { at: Date.now(), note });
+  return note;
+};
+
+// src/features.ts
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join3 } from "node:path";
+
+// src/runtime.ts
+import { spawn } from "node:child_process";
+import { accessSync, closeSync, constants, mkdirSync, openSync, readFileSync as readFileSync3, statSync as statSync3, writeFileSync } from "node:fs";
+import { delimiter, dirname as dirname2, join as join2 } from "node:path";
+var pluginRoot = (env = process.env) => env["CLAUDE_PLUGIN_ROOT"] ?? dirname2(import.meta.dirname);
+var isMissing = (error) => {
+  const code = typeof error === "object" && error !== null ? error.code : void 0;
+  return code === "ENOENT" || code === "ENOTDIR";
+};
+var pluginFile = (parts, env = process.env) => {
+  try {
+    return readFileSync3(join2(pluginRoot(env), ...parts), "utf8");
+  } catch (error) {
+    if (isMissing(error)) {
+      return void 0;
+    }
+    throw error;
+  }
+};
+var onPath = (name, env = process.env) => {
+  const extensions = process.platform === "win32" ? (env["PATHEXT"] ?? ".EXE;.CMD;.BAT").split(";") : [""];
+  for (const dir of (env["PATH"] ?? "").split(delimiter)) {
+    for (const extension of extensions) {
+      try {
+        accessSync(join2(dir, `${name}${extension}`), constants.X_OK);
+        return true;
+      } catch {
+      }
+    }
+  }
+  return false;
+};
+var startDetached = (command, args, options) => {
+  mkdirSync(dirname2(options.log), { recursive: true });
+  const out = openSync(options.log, "w");
+  try {
+    const child = spawn(command, args, { cwd: options.cwd, detached: true, stdio: ["ignore", out, out], env: { ...options.env ?? process.env } });
+    child.on("error", () => void 0);
+    child.unref();
+  } finally {
+    closeSync(out);
+  }
+};
+var claimIfDue = (stamp, everyMs, now = Date.now()) => {
+  try {
+    if (now - statSync3(stamp).mtimeMs < everyMs) {
+      return false;
+    }
+  } catch {
+  }
+  try {
+    mkdirSync(dirname2(stamp), { recursive: true });
+    writeFileSync(stamp, `${now}
+`);
+    return true;
+  } catch (error) {
+    process.stderr.write(`intentic: ${stamp} cannot be written (${error instanceof Error ? error.message : String(error)}), so what it paces is skipped
+`);
+    return false;
+  }
+};
+var projectSlug = (project) => project.replace(/[^a-zA-Z0-9]/g, "-");
+
+// src/features.ts
+var OPTIONS = {
+  output_cleaners: {
+    type: "boolean",
+    title: "Trim Bash output",
+    description: "Clean what a successful command printed before Claude reads it (progress bars, install chatter, repeated lines, the middle of huge logs), keep the full text retrievable with `retrieve-output`, and ledger what each cleaner saved.",
+    default: true
+  },
+  cleaners: {
+    type: "string",
+    title: "Cleaners",
+    description: "Which cleaners run, as the sandbox spells it: empty for all, `-cap,-wide` to switch some off, `git,pnpm` to allow only those. `/intentic:stats` lists them by what they saved.",
+    default: ""
+  },
+  output_holdout: {
+    type: "number",
+    title: "Untrimmed share",
+    description: "Share of commands left untrimmed, so the saving can be measured against a real comparison and not only computed. 0 turns the comparison off; the exact per-command saving is reported either way.",
+    default: 0,
+    min: 0,
+    max: 0.5
+  },
+  project_map: {
+    type: "boolean",
+    title: "Project map",
+    description: "Open each session with a map of the project it starts in: its areas, what each is for, and where Claude is standing. Worked out from the tree every time, never stored, so it cannot go stale.",
+    default: true
+  },
+  field_notes: {
+    type: "boolean",
+    title: "Field notes",
+    description: "Open each session with this project's field notes: the traps past sessions hit and the commands that really verify. Written by `/intentic:field-notes` from your own sessions here; nothing is sent until you run it once.",
+    default: true
+  },
+  iq: {
+    type: "boolean",
+    title: "iq search",
+    description: "Teach Claude the `iq` code search CLI and recall past sessions on a matching prompt. Needs `npm i -g @intentic/iq`; without it this switch does nothing and says so once.",
+    default: true
+  },
+  fileq: {
+    type: "boolean",
+    title: "fileq",
+    description: "Let Claude read documents, PDFs, spreadsheets, slides, notebooks, images, audio and archives as markdown with the bundled `fileq` CLI. Off makes the command refuse; its one-line skill description stays listed, since a plugin cannot hide its own skills.",
+    default: true
+  },
+  shadows: {
+    type: "boolean",
+    title: "Document shadows",
+    description: "Keep a markdown rendering of every document in the project up to date in the background (a sweep at session start and every ten minutes, and each binary file Claude writes), so a read finds one ready. Costs background CPU on a document-heavy project.",
+    default: false
+  },
+  holdout: {
+    type: "number",
+    title: "Measured share",
+    description: "Share of sessions opened without the map, the field notes and the iq teaching, so `/intentic:stats` can show what each changed. 0 sends them to every session and measures nothing.",
+    default: 0.1,
+    min: 0,
+    max: 0.5
+  }
+};
+var asBoolean = (raw, fallback) => {
+  const value = raw?.trim().toLowerCase();
+  if (value === "true" || value === "1" || value === "yes" || value === "on") {
+    return true;
+  }
+  if (value === "false" || value === "0" || value === "no" || value === "off") {
+    return false;
+  }
+  return fallback;
+};
+var asShare = (raw, option) => {
+  const value = raw === void 0 || raw.trim() === "" ? Number.NaN : Number(raw);
+  return Number.isFinite(value) ? Math.min(option.max, Math.max(option.min, value)) : option.default;
+};
+var optionEnvName = (key) => `CLAUDE_PLUGIN_OPTION_${key.toUpperCase()}`;
+var readOptions = (env = process.env) => {
+  const entries = Object.keys(OPTIONS).map((key) => {
+    const option = OPTIONS[key];
+    const raw = env[optionEnvName(key)];
+    if (option.type === "boolean") {
+      return [key, asBoolean(raw, option.default)];
+    }
+    if (option.type === "number") {
+      return [key, asShare(raw, option)];
+    }
+    return [key, raw ?? option.default];
+  });
+  return Object.fromEntries(entries);
+};
+var optionsFile = (data) => join3(data, "options.json");
+var saveOptions = (data, options) => {
+  mkdirSync2(data, { recursive: true });
+  writeFileSync2(optionsFile(data), `${JSON.stringify(options)}
+`);
+};
+
+// src/hook-io.ts
+import { homedir } from "node:os";
+import { join as join4 } from "node:path";
+var readStdin = async () => {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString("utf8");
+};
+var parseHookInput = (text) => {
+  try {
+    const value = JSON.parse(text);
+    return typeof value === "object" && value !== null ? value : void 0;
+  } catch {
+    return void 0;
+  }
+};
+var runHook = async (handle) => {
+  try {
+    const raw = await readStdin();
+    const input = parseHookInput(raw);
+    if (input === void 0) {
+      return;
+    }
+    const answer = await handle(input, raw);
+    if (typeof answer === "string") {
+      process.stdout.write(answer);
+    } else if (answer !== void 0) {
+      process.stdout.write(`${JSON.stringify(answer)}
+`);
+    }
+  } catch (error) {
+    process.stderr.write(`intentic: ${error instanceof Error ? error.message : String(error)}
+`);
+  }
+};
+var dataDir = (env = process.env) => env["CLAUDE_PLUGIN_DATA"] ?? join4(env["CLAUDE_CONFIG_DIR"] ?? join4(homedir(), ".claude"), "plugins", "data", "intentic-intentic");
+var projectDir = (input, env = process.env) => env["CLAUDE_PROJECT_DIR"] ?? input.cwd ?? process.cwd();
+var fieldNotesFile = (project) => join4(project, ".claude", "intentic", "field-notes.toon");
+
+// src/sessions.ts
+import { appendFileSync, mkdirSync as mkdirSync3, readFileSync as readFileSync5 } from "node:fs";
+import { dirname as dirname3, join as join5 } from "node:path";
+
+// ../agent-context/src/experiments.ts
+import { createHash as createHash2 } from "node:crypto";
+var experimentArm = (experiment, id, holdout) => {
+  if (id === void 0) {
+    return Math.random() >= holdout;
+  }
+  const bucket = createHash2("sha256").update(`${experiment}:${id}`).digest().readUInt32BE(0) / 4294967296;
+  return bucket >= holdout;
+};
+
+// src/sessions.ts
+var SALTS = { map: "workspace-map", notes: "field-notes", iq: "iq-search" };
+var MECHANISM_ON = {
+  map: (options) => options.project_map,
+  notes: (options) => options.field_notes,
+  iq: (options) => options.iq
+};
+var armsOf = (options, session) => {
+  const arms = {};
+  for (const mechanism of Object.keys(SALTS)) {
+    if (MECHANISM_ON[mechanism](options) && options.holdout > 0 && session !== void 0) {
+      arms[mechanism] = experimentArm(SALTS[mechanism], session, options.holdout);
+    }
+  }
+  return arms;
+};
+var sends = (options, arms, mechanism) => MECHANISM_ON[mechanism](options) && arms[mechanism] !== false;
+var measuredArms = (arms, offered) => Object.fromEntries(Object.entries(arms).filter(([mechanism]) => offered[mechanism] === true));
+var sessionsFile = (data) => join5(data, "sessions.jsonl");
+var recordSession = (data, row) => {
+  const file = sessionsFile(data);
+  mkdirSync3(dirname3(file), { recursive: true });
+  appendFileSync(file, `${JSON.stringify(row)}
+`);
+};
+
+// src/shadows.ts
+import { relative as relative2, isAbsolute, join as join6 } from "node:path";
+var SWEEP_EVERY_MS = 10 * 6e4;
+var fileq = (env) => join6(pluginRoot(env), "dist", "fileq.mjs");
+var logOf = (data, project, what) => join6(data, "shadows", `${projectSlug(project)}.${what}.log`);
+var fileqEnv = (env, project) => ({ ...env, WORKSPACE_ROOT: project });
+var sweepIfDue = (data, project, env = process.env, now = Date.now()) => {
+  if (!claimIfDue(join6(data, "shadows", `${projectSlug(project)}.stamp`), SWEEP_EVERY_MS, now)) {
+    return false;
+  }
+  startDetached(process.execPath, [fileq(env), "sweep", "--json"], { cwd: project, log: logOf(data, project, "sweep"), env: fileqEnv(env, project) });
+  return true;
+};
+
+// src/session-start.ts
+var NOTES_BUDGET = 4e3;
+var NOTICE_EVERY_MS = 24 * 60 * 6e4;
+var TOLD_ON = /* @__PURE__ */ new Set(["startup", "clear", "compact"]);
+var COUNTED_ON = /* @__PURE__ */ new Set(["startup", "clear"]);
+var compose = (options, input, project, arms, data, env) => {
+  const context = [];
+  const notices = [];
+  const notice = (id, text) => {
+    if (claimIfDue(join7(data, "notices", `${id}.stamp`), NOTICE_EVERY_MS)) {
+      notices.push(text);
+    }
+  };
+  const iq = options.iq && onPath("iq", env);
+  const sent = {};
+  const offered = {};
+  let notesRevision;
+  if (options.project_map) {
+    const note = workspaceMapNote({ root: project, cwd: input.cwd ?? project, exactPaths: iq ? "`iq files` or Read" : "Glob or Read" });
+    offered.map = note !== void 0;
+    if (note !== void 0 && sends(options, arms, "map")) {
+      context.push(note);
+      sent.map = note.length;
+    }
+  }
+  if (options.field_notes) {
+    const brief = fieldNotes({
+      file: fieldNotesFile(project),
+      title: "Field notes for this project",
+      budget: NOTES_BUDGET,
+      onUnreadable: (why) => notice(`notes-${projectSlug(project)}`, `intentic: this project's field notes were not sent: ${why}. Run /intentic:field-notes to rewrite them.`)
+    });
+    notesRevision = brief?.revision;
+    offered.notes = brief !== void 0;
+    if (brief !== void 0 && sends(options, arms, "notes")) {
+      context.push(brief.text);
+      sent.notes = brief.chars;
+    }
+  }
+  if (options.iq) {
+    if (iq) {
+      const nudge = pluginFile(["generated", "iq-nudge.txt"], env);
+      offered.iq = nudge !== void 0;
+      if (nudge !== void 0 && sends(options, arms, "iq")) {
+        context.push(`## iq workspace search
+
+${nudge.trim()}`);
+        sent.iq = true;
+      }
+      startDetached("iq", ["sessions", "ingest"], { cwd: project, log: join7(data, "iq", `${projectSlug(project)}.ingest.log`), env });
+    } else {
+      notice("iq-missing", "intentic: iq search is on but the `iq` CLI is not installed (`npm i -g @intentic/iq`), so nothing was taught.");
+    }
+  }
+  return { context, row: { arms: measuredArms(arms, offered), sent, ...notesRevision === void 0 ? {} : { notesRevision } }, notices };
+};
+var exportEnv = (options, project, env) => {
+  const file = env["CLAUDE_ENV_FILE"];
+  if (file === void 0 || file === "") {
+    return;
+  }
+  const quoted = `'${project.replaceAll("'", `'\\''`)}'`;
+  appendFileSync2(file, `export INTENTIC_PROJECT_DIR=${quoted}
+export INTENTIC_FILEQ=${options.fileq ? "1" : "0"}
+`);
+};
+var record = (what, write) => {
+  try {
+    write();
+  } catch (error) {
+    process.stderr.write(`intentic: ${what} not recorded: ${error instanceof Error ? error.message : String(error)}
+`);
+  }
+};
+var sessionStart = (input, env = process.env) => {
+  const options = readOptions(env);
+  const data = dataDir(env);
+  const project = projectDir(input, env);
+  const source = input.source ?? "startup";
+  record("the switches", () => saveOptions(data, options));
+  exportEnv(options, project, env);
+  if (options.shadows && existsSync(project)) {
+    sweepIfDue(data, project, env);
+  }
+  if (!TOLD_ON.has(source)) {
+    return void 0;
+  }
+  const { context, row, notices } = compose(options, input, project, armsOf(options, input.session_id), data, env);
+  const session = input.session_id;
+  if (COUNTED_ON.has(source) && session !== void 0) {
+    record(
+      "the session",
+      () => recordSession(data, {
+        ts: Date.now(),
+        session,
+        project,
+        ...input.transcript_path === void 0 ? {} : { transcript: input.transcript_path },
+        ...row
+      })
+    );
+  }
+  if (context.length === 0 && notices.length === 0) {
+    return void 0;
+  }
+  return {
+    ...notices.length === 0 ? {} : { systemMessage: notices.join("\n") },
+    hookSpecificOutput: { hookEventName: "SessionStart", ...context.length === 0 ? {} : { additionalContext: context.join("\n\n") } }
+  };
+};
+if (process.argv[1]?.endsWith("session-start.mjs")) {
+  await runHook((input) => sessionStart(input));
+}
+export {
+  sessionStart
+};