token-goat 2.9.13 → 2.9.15

package/dist/token-goat-chunk-S4XRY446.mjs

@@ -0,0 +1,2637 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  registerReset
+} from "./token-goat-chunk-EEIDFMEM.mjs";
+import {
+  ENV_KEYS,
+  atomicWriteText,
+  canonicalize,
+  configPath,
+  decodeSource,
+  extractErrorMessage,
+  foldPath,
+  projectConfigPath,
+  runGit
+} from "./token-goat-chunk-PM76YS22.mjs";
+import {
+  normalizeDarwinSystemAlias
+} from "./token-goat-chunk-ERTXEKB6.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/bridges/registry.ts
+init_define_import_meta_env();
+var KNOWN_HARNESS_NAMES = /* @__PURE__ */ new Set([
+  "claudecode",
+  "codex",
+  "opencode",
+  "gemini",
+  "hermes",
+  "openclaw",
+  "pi",
+  "copilot_cli",
+  "grok",
+  "qwen",
+  "kimi",
+  "vscode",
+  "visualstudio",
+  "generic"
+]);
+function detectHarness() {
+  const env = process.env;
+  const override = (env[ENV_KEYS.HARNESS_OVERRIDE] ?? "").toLowerCase().trim();
+  if (override && KNOWN_HARNESS_NAMES.has(override)) {
+    return override;
+  }
+  if (env["HERMES_SESSION_ID"] || env["HERMES_HOME"]) {
+    return "hermes";
+  }
+  if (env["TERM_PROGRAM"] === "claude-code" || env["CLAUDE_CODE_VERSION"] !== void 0 || env["CLAUDE_CODE_SESSION_ID"]) {
+    return "claudecode";
+  }
+  if (env["CODEX_SESSION_ID"] !== void 0 || env["CODEX_SESSION"]) {
+    return "codex";
+  }
+  if (env["OPENCODE_SESSION_ID"] !== void 0 || env["OPENCODE_SESSION"]) {
+    return "opencode";
+  }
+  if (env["GROK_SESSION_ID"] !== void 0) {
+    return "grok";
+  }
+  if (env["OPENCLAW_SESSION_ID"] !== void 0) {
+    return "openclaw";
+  }
+  if (env["ANTHROPIC_API_KEY"]) {
+    return "claudecode";
+  }
+  if (env["OPENAI_API_KEY"] && !env["ANTHROPIC_API_KEY"]) {
+    return "codex";
+  }
+  if ((env["GEMINI_API_KEY"] || env["GOOGLE_API_KEY"]) && !env["ANTHROPIC_API_KEY"]) {
+    return "gemini";
+  }
+  return "generic";
+}
+var _cached = null;
+function getHarnessName() {
+  if (_cached === null) {
+    _cached = detectHarness();
+  }
+  return _cached;
+}
+function resetHarnessCache() {
+  _cached = null;
+}
+registerReset(resetHarnessCache);
+
+// src/env.ts
+init_define_import_meta_env();
+var FALSY_ENV_VALUES = /* @__PURE__ */ new Set(["0", "false", "no", "off"]);
+var TRUTHY_ENV_VALUES = /* @__PURE__ */ new Set(["1", "true", "yes", "on"]);
+function envStr(key, defaultVal) {
+  const raw = process.env[key];
+  if (raw === void 0) return defaultVal;
+  const trimmed = raw.trim();
+  return trimmed === "" ? defaultVal : trimmed;
+}
+function envBool(key, defaultVal) {
+  const raw = process.env[key];
+  if (raw === void 0) return defaultVal;
+  const norm = raw.trim().toLowerCase();
+  if (norm === "") return defaultVal;
+  if (TRUTHY_ENV_VALUES.has(norm)) return true;
+  if (FALSY_ENV_VALUES.has(norm)) return false;
+  return defaultVal;
+}
+function envInt(key, defaultVal, min, max) {
+  const raw = process.env[key];
+  if (raw === void 0) return defaultVal;
+  const norm = raw.trim();
+  if (norm === "") return defaultVal;
+  if (!/^[+-]?\d+$/.test(norm)) return defaultVal;
+  const val = parseInt(norm, 10);
+  if (!Number.isFinite(val)) return defaultVal;
+  let clamped = val;
+  if (min !== void 0) clamped = Math.max(min, clamped);
+  if (max !== void 0) clamped = Math.min(max, clamped);
+  return clamped;
+}
+function envStrList(key, defaultVal, delimiter2) {
+  const raw = process.env[key];
+  if (raw === void 0) return defaultVal;
+  const entries = raw.split(delimiter2).map((s) => s.trim()).filter((s) => s !== "");
+  return entries.length > 0 ? entries : defaultVal;
+}
+
+// src/fingerprint.ts
+init_define_import_meta_env();
+import { createHash } from "node:crypto";
+import * as fs from "node:fs";
+function fingerprintContent(content) {
+  const hash = createHash("sha256");
+  hash.update(typeof content === "string" ? Buffer.from(content, "utf-8") : content);
+  return hash.digest("hex");
+}
+function shortFingerprint(content) {
+  return fingerprintContent(content).slice(0, 16);
+}
+function fingerprintFile(filePath) {
+  let data;
+  try {
+    data = fs.readFileSync(filePath);
+  } catch {
+    return null;
+  }
+  return fingerprintContent(data);
+}
+function fileIsAbsent(filePath) {
+  try {
+    return fs.statSync(filePath, { throwIfNoEntry: false }) === void 0;
+  } catch {
+    return false;
+  }
+}
+
+// src/ocr_languages.ts
+init_define_import_meta_env();
+var DEFAULT_OCR_LANG = "eng";
+var SUPPORTED_OCR_LANG_CODES = [
+  "eng",
+  "fra",
+  "spa",
+  "deu",
+  "ita",
+  "por",
+  "nld",
+  "pol",
+  "rus",
+  "tur",
+  "swe",
+  "ara",
+  "chi_sim",
+  "chi_tra",
+  "jpn",
+  "kor"
+];
+var SUPPORTED_SET = new Set(SUPPORTED_OCR_LANG_CODES);
+function isSupportedOcrLang(lang) {
+  return SUPPORTED_SET.has(lang);
+}
+function resolveOcrLangs(input) {
+  const result = [DEFAULT_OCR_LANG];
+  if (!input) return result;
+  const tokens = input.split(/[+,;\s]+/).map((s) => s.trim().toLowerCase());
+  for (const token of tokens) {
+    if (token && isSupportedOcrLang(token) && !result.includes(token)) {
+      result.push(token);
+    }
+  }
+  return result;
+}
+
+// src/project.ts
+init_define_import_meta_env();
+import * as fs2 from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+var PROJECT_MARKERS = [
+  ".git",
+  "package.json",
+  "pyproject.toml",
+  "Cargo.toml",
+  "go.mod",
+  "shopify.app.toml",
+  "_config.yml",
+  "deno.json",
+  "deno.jsonc"
+];
+var REPO_CONTAINER_THRESHOLD = 3;
+function projectHash(canonicalRoot) {
+  return shortFingerprint(foldPath(canonicalRoot));
+}
+function makeProjectAt(root) {
+  let canonical;
+  try {
+    canonical = canonicalize(root);
+  } catch (exc) {
+    throw new Error(
+      `makeProjectAt: could not resolve path: ${extractErrorMessage(exc)}`,
+      { cause: exc }
+    );
+  }
+  try {
+    const stat = fs2.statSync(canonical);
+    if (!stat.isDirectory()) {
+      throw new Error(`makeProjectAt: path is not a directory: ${canonical}`);
+    }
+  } catch (exc) {
+    if (exc instanceof Error && exc.message.includes("ENOENT")) {
+      throw new Error(`makeProjectAt: path does not exist: ${canonical}`, { cause: exc });
+    }
+    throw exc;
+  }
+  const hash = projectHash(canonical);
+  return { root: canonical, hash, marker: "manual" };
+}
+function isRepoContainer(pathStr) {
+  let nestedRepos = 0;
+  try {
+    const entries = fs2.readdirSync(pathStr, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const gitPath = path.join(pathStr, entry.name, ".git");
+        if (fs2.existsSync(gitPath)) {
+          let isGitDir = false;
+          try {
+            isGitDir = fs2.statSync(gitPath).isDirectory();
+          } catch {
+          }
+          if (isGitDir) {
+            nestedRepos++;
+            if (nestedRepos >= REPO_CONTAINER_THRESHOLD) {
+              return true;
+            }
+          }
+        }
+      }
+    }
+  } catch {
+    return false;
+  }
+  return false;
+}
+function markerExists(current, marker) {
+  const markerPath = path.join(current, marker);
+  try {
+    if (!fs2.existsSync(markerPath)) {
+      return false;
+    }
+    const stat = fs2.lstatSync(markerPath);
+    if (!stat.isSymbolicLink()) {
+      return true;
+    }
+    const resolved = fs2.realpathSync(markerPath);
+    const rel = path.relative(path.resolve(current), path.resolve(resolved));
+    return !rel.startsWith("..") && !path.isAbsolute(rel);
+  } catch {
+    return false;
+  }
+}
+function findProject(cwd) {
+  let p;
+  try {
+    p = canonicalize(cwd);
+  } catch {
+    return null;
+  }
+  let sysTemp = null;
+  try {
+    sysTemp = canonicalize(os.tmpdir());
+  } catch {
+  }
+  let current = p;
+  while (true) {
+    if (sysTemp && normalizeDarwinSystemAlias(foldPath(current)) === normalizeDarwinSystemAlias(foldPath(sysTemp))) {
+      break;
+    }
+    for (const marker of PROJECT_MARKERS) {
+      if (markerExists(current, marker)) {
+        if (!isRepoContainer(current)) {
+          return {
+            root: current,
+            hash: projectHash(current),
+            marker
+          };
+        }
+        break;
+      }
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return null;
+}
+var _displayRootCache = null;
+function getDisplayRoot(explicitRoot) {
+  if (explicitRoot !== void 0) return explicitRoot;
+  const cwd = process.cwd();
+  if (_displayRootCache !== null && _displayRootCache.cwd === cwd) return _displayRootCache.root;
+  const project = findProject(cwd);
+  const root = project !== null ? project.root : void 0;
+  _displayRootCache = { cwd, root };
+  return root;
+}
+registerReset(() => {
+  _displayRootCache = null;
+});
+function isUnderSystemTemp(filePath) {
+  let sysTemp;
+  try {
+    sysTemp = canonicalize(os.tmpdir());
+  } catch {
+    return false;
+  }
+  let target;
+  try {
+    target = canonicalize(filePath);
+  } catch {
+    return false;
+  }
+  const foldedTemp = normalizeDarwinSystemAlias(foldPath(sysTemp));
+  const foldedTarget = normalizeDarwinSystemAlias(foldPath(target));
+  return foldedTarget === foldedTemp || foldedTarget.startsWith(`${foldedTemp}/`);
+}
+function resolveProjectRoot(opts) {
+  const base = opts?.project !== void 0 ? path.resolve(opts.project) : process.cwd();
+  const toplevel = runGit(["rev-parse", "--show-toplevel"], { cwd: base });
+  if (toplevel.exitCode === 0) {
+    const trimmed = toplevel.stdout.trim();
+    if (trimmed.length > 0) return canonicalize(trimmed);
+  }
+  const project = findProject(base);
+  if (project !== null) return project.root;
+  return canonicalize(base);
+}
+
+// src/config_project.ts
+init_define_import_meta_env();
+import * as fs3 from "node:fs";
+
+// node_modules/smol-toml/dist/index.js
+init_define_import_meta_env();
+
+// node_modules/smol-toml/dist/parse.js
+init_define_import_meta_env();
+
+// node_modules/smol-toml/dist/struct.js
+init_define_import_meta_env();
+
+// node_modules/smol-toml/dist/primitive.js
+init_define_import_meta_env();
+
+// node_modules/smol-toml/dist/date.js
+init_define_import_meta_env();
+var DATE_TIME_RE = /^(\d{4}-\d{2}-\d{2})?[T ]?(?:(\d{2}):\d{2}(?::\d{2}(?:\.\d+)?)?)?(Z|[-+]\d{2}:\d{2})?$/i;
+var TomlDate = class _TomlDate extends Date {
+  #hasDate = false;
+  #hasTime = false;
+  #offset = null;
+  constructor(date) {
+    let hasDate = true;
+    let hasTime = true;
+    let offset = "Z";
+    if (typeof date === "string") {
+      let match = date.match(DATE_TIME_RE);
+      if (match) {
+        if (!match[1]) {
+          hasDate = false;
+          date = `0000-01-01T${date}`;
+        }
+        hasTime = !!match[2];
+        hasTime && date[10] === " " && (date = date.replace(" ", "T"));
+        if (match[2] && +match[2] > 23) {
+          date = "";
+        } else {
+          offset = match[3] || null;
+          date = date.toUpperCase();
+          if (!offset && hasTime)
+            date += "Z";
+        }
+      } else {
+        date = "";
+      }
+    }
+    super(date);
+    if (!isNaN(this.getTime())) {
+      this.#hasDate = hasDate;
+      this.#hasTime = hasTime;
+      this.#offset = offset;
+    }
+  }
+  isDateTime() {
+    return this.#hasDate && this.#hasTime;
+  }
+  isLocal() {
+    return !this.#hasDate || !this.#hasTime || !this.#offset;
+  }
+  isDate() {
+    return this.#hasDate && !this.#hasTime;
+  }
+  isTime() {
+    return this.#hasTime && !this.#hasDate;
+  }
+  isValid() {
+    return this.#hasDate || this.#hasTime;
+  }
+  toISOString() {
+    let iso = super.toISOString();
+    if (this.isDate())
+      return iso.slice(0, 10);
+    if (this.isTime())
+      return iso.slice(11, 23);
+    if (this.#offset === null)
+      return iso.slice(0, -1);
+    if (this.#offset === "Z")
+      return iso;
+    let offset = +this.#offset.slice(1, 3) * 60 + +this.#offset.slice(4, 6);
+    offset = this.#offset[0] === "-" ? offset : -offset;
+    let offsetDate = new Date(this.getTime() - offset * 6e4);
+    return offsetDate.toISOString().slice(0, -1) + this.#offset;
+  }
+  static wrapAsOffsetDateTime(jsDate, offset = "Z") {
+    let date = new _TomlDate(jsDate);
+    date.#offset = offset;
+    return date;
+  }
+  static wrapAsLocalDateTime(jsDate) {
+    let date = new _TomlDate(jsDate);
+    date.#offset = null;
+    return date;
+  }
+  static wrapAsLocalDate(jsDate) {
+    let date = new _TomlDate(jsDate);
+    date.#hasTime = false;
+    date.#offset = null;
+    return date;
+  }
+  static wrapAsLocalTime(jsDate) {
+    let date = new _TomlDate(jsDate);
+    date.#hasDate = false;
+    date.#offset = null;
+    return date;
+  }
+};
+
+// node_modules/smol-toml/dist/error.js
+init_define_import_meta_env();
+function getLineColFromPtr(string, ptr) {
+  let lines = string.slice(0, ptr).split(/\r\n|\n|\r/g);
+  return [lines.length, lines.pop().length + 1];
+}
+function makeCodeBlock(string, line, column) {
+  let lines = string.split(/\r\n|\n|\r/g);
+  let codeblock = "";
+  let numberLen = (Math.log10(line + 1) | 0) + 1;
+  for (let i = line - 1; i <= line + 1; i++) {
+    let l = lines[i - 1];
+    if (!l)
+      continue;
+    codeblock += i.toString().padEnd(numberLen, " ");
+    codeblock += ":  ";
+    codeblock += l;
+    codeblock += "\n";
+    if (i === line) {
+      codeblock += " ".repeat(numberLen + column + 2);
+      codeblock += "^\n";
+    }
+  }
+  return codeblock;
+}
+var TomlError = class extends Error {
+  line;
+  column;
+  codeblock;
+  constructor(message, options) {
+    const [line, column] = getLineColFromPtr(options.toml, options.ptr);
+    const codeblock = makeCodeBlock(options.toml, line, column);
+    super(`Invalid TOML document: ${message}
+
+${codeblock}`, options);
+    this.line = line;
+    this.column = column;
+    this.codeblock = codeblock;
+  }
+};
+
+// node_modules/smol-toml/dist/util.js
+init_define_import_meta_env();
+function indexOfNewline(str, start = 0) {
+  let idx = str.indexOf("\n", start);
+  if (str.charCodeAt(idx - 1) === 13)
+    idx--;
+  return idx;
+}
+function skipComment(ctx) {
+  for (; ctx.p < ctx.s.length; ctx.p++) {
+    let c = ctx.s.charCodeAt(ctx.p);
+    if (c === 10)
+      break;
+    if (c === 13 && ctx.s.charCodeAt(ctx.p + 1) === 10) {
+      ctx.p++;
+      break;
+    }
+    if (c < 32 && c !== 9 || c === 127) {
+      throw new TomlError("control characters are not allowed in comments", {
+        toml: ctx.s,
+        ptr: ctx.p
+      });
+    }
+  }
+}
+function skipVoid(ctx, banNewLines, banComments) {
+  let c;
+  while (1) {
+    while ((c = ctx.s.charCodeAt(ctx.p)) === 32 || c === 9 || !banNewLines && (c === 10 || c === 13 && ctx.s.charCodeAt(ctx.p + 1) === 10))
+      ctx.p++;
+    if (banComments || c !== 35)
+      break;
+    skipComment(ctx);
+  }
+}
+function skipUntil(ctx, sep, end) {
+  let ptr = ctx.p;
+  if (!end) {
+    ptr = indexOfNewline(ctx.s, ptr);
+    ctx.p = ptr < 0 ? ctx.s.length : ptr;
+    return;
+  }
+  for (; ctx.p < ctx.s.length; ctx.p++) {
+    let c = ctx.s.charCodeAt(ctx.p);
+    if (c === 35) {
+      skipComment(ctx);
+    } else if (c === end || c === sep) {
+      return;
+    }
+  }
+  throw new TomlError("cannot find end of structure", {
+    toml: ctx.s,
+    ptr
+  });
+}
+
+// node_modules/smol-toml/dist/primitive.js
+var INT_REGEX = /^((0x[0-9a-fA-F](_?[0-9a-fA-F])*)|(([+-]|0[ob])?\d(_?\d)*))$/;
+var FLOAT_REGEX = /^[+-]?\d(_?\d)*(\.\d(_?\d)*)?([eE][+-]?\d(_?\d)*)?$/;
+var LEADING_ZERO = /^[+-]?0[0-9_]/;
+function parseString(ctx) {
+  let start = ctx.p;
+  let c = ctx.s.charCodeAt(ctx.p++);
+  let first = c;
+  let isLiteral = c === 39;
+  let isMultiline = c === ctx.s.charCodeAt(ctx.p) && c === ctx.s.charCodeAt(ctx.p + 1);
+  if (isMultiline) {
+    if ((c = ctx.s.charCodeAt(ctx.p += 2)) === 10)
+      ctx.p++;
+    else if (c === 13 && ctx.s.charCodeAt(ctx.p + 1) === 10)
+      ctx.p += 2;
+  }
+  let parsed = "";
+  let sliceStart = ctx.p;
+  let state = 0;
+  for (; ctx.p < ctx.s.length; ctx.p++) {
+    c = ctx.s.charCodeAt(ctx.p);
+    if (isMultiline && (c === 10 || c === 13 && ctx.s.charCodeAt(ctx.p + 1) === 10)) {
+      state = state && 3;
+    } else if (c < 32 && c !== 9 || c === 127) {
+      throw new TomlError("control characters are not allowed in strings", {
+        toml: ctx.s,
+        ptr: ctx.p
+      });
+    } else if ((!state || state === 3) && c === first && (!isMultiline || ctx.s.charCodeAt(ctx.p + 1) === first && ctx.s.charCodeAt(ctx.p + 2) === first)) {
+      if (isMultiline) {
+        if (ctx.s.charCodeAt(ctx.p + 3) === first)
+          ctx.p++;
+        if (ctx.s.charCodeAt(ctx.p + 3) === first)
+          ctx.p++;
+      }
+      if (!state)
+        parsed += ctx.s.slice(sliceStart, ctx.p);
+      ctx.p += isMultiline ? 3 : 1;
+      return parsed;
+    } else if (!state) {
+      if (!isLiteral && c === 92) {
+        parsed += ctx.s.slice(sliceStart, sliceStart = ctx.p);
+        state = 1;
+      }
+    } else if (state === 1) {
+      if (c === 120 || c === 117 || c === 85) {
+        let value = 0;
+        let len = c === 120 ? 2 : c === 117 ? 4 : 8;
+        for (let j = 0; j < len; j++, ctx.p++) {
+          let hex = ctx.s.charCodeAt(ctx.p + 1);
+          let digit = (
+            /* 0-9 */
+            hex >= 48 && hex <= 57 ? hex - 48 : (
+              /* A-F */
+              hex >= 65 && hex <= 70 ? hex - 65 + 10 : (
+                /* a-f */
+                hex >= 97 && hex <= 102 ? hex - 97 + 10 : -1
+              )
+            )
+          );
+          if (digit < 0)
+            throw new TomlError("invalid non-hex character in unicode escape", { toml: ctx.s, ptr: ctx.p + 1 });
+          value = value << 4 | digit;
+        }
+        if (value < 0 || value > 1114111 || value >= 55296 && value <= 57343) {
+          throw new TomlError("invalid unicode escape", { toml: ctx.s, ptr: ctx.p });
+        }
+        parsed += String.fromCodePoint(value);
+        sliceStart = ctx.p + 1;
+        state = 0;
+      } else if (c === 32 || c === 9) {
+        state = 2;
+      } else {
+        if (c === 98)
+          parsed += "\b";
+        else if (c === 116)
+          parsed += "	";
+        else if (c === 110)
+          parsed += "\n";
+        else if (c === 102)
+          parsed += "\f";
+        else if (c === 114)
+          parsed += "\r";
+        else if (c === 101)
+          parsed += "\x1B";
+        else if (c === 34)
+          parsed += '"';
+        else if (c === 92)
+          parsed += "\\";
+        else
+          throw new TomlError("unrecognized escape sequence", { toml: ctx.s, ptr: ctx.p });
+        sliceStart = ctx.p + 1;
+        state = 0;
+      }
+    } else if (c !== 32 && c !== 9) {
+      if (state === 2) {
+        throw new TomlError("invalid escape: only line-ending whitespace may be escaped", {
+          toml: ctx.s,
+          ptr: sliceStart
+        });
+      }
+      state = !isLiteral && c === 92 ? 1 : 0;
+      sliceStart = ctx.p;
+    }
+  }
+  throw new TomlError("unfinished string", { toml: ctx.s, ptr: start });
+}
+function sliceAndTrimEndOf(ctx, start, end) {
+  let value = ctx.s.slice(start, end);
+  let commentIdx = value.indexOf("#");
+  if (commentIdx > 0) {
+    skipComment({ s: value, p: commentIdx, d: 0 });
+    value = value.slice(0, commentIdx);
+  }
+  return value.trimEnd();
+}
+function parseValue(ctx, integersAsBigInt, end) {
+  let ptr = ctx.p;
+  let err = { toml: ctx.s, ptr };
+  skipUntil(ctx, 44, end);
+  let value = sliceAndTrimEndOf(ctx, ptr, ctx.p);
+  if (!value)
+    throw new TomlError("incomplete declaration: value expected", err);
+  if (value === "-inf")
+    return -Infinity;
+  if (value === "inf" || value === "+inf")
+    return Infinity;
+  if (value === "nan" || value === "+nan" || value === "-nan")
+    return NaN;
+  if (value === "-0")
+    return integersAsBigInt ? 0n : 0;
+  let isInt = INT_REGEX.test(value);
+  if (isInt || FLOAT_REGEX.test(value)) {
+    if (LEADING_ZERO.test(value)) {
+      throw new TomlError("leading zeroes are not allowed", err);
+    }
+    value = value.replace(/_/g, "");
+    let numeric = +value;
+    if (isNaN(numeric)) {
+      throw new TomlError("invalid number", err);
+    }
+    if (isInt) {
+      if ((isInt = !Number.isSafeInteger(numeric)) && !integersAsBigInt) {
+        throw new TomlError("integer value cannot be represented losslessly", err);
+      }
+      if (isInt || integersAsBigInt === true)
+        numeric = BigInt(value);
+    }
+    return numeric;
+  }
+  const date = new TomlDate(value);
+  if (!date.isValid())
+    throw new TomlError("invalid value", err);
+  return date;
+}
+
+// node_modules/smol-toml/dist/extract.js
+init_define_import_meta_env();
+function extractValue(ctx, end, integersAsBigInt) {
+  let ptr = ctx.p;
+  let c = ctx.s.charCodeAt(ptr);
+  if (c === 91 || c === 123) {
+    if (!ctx.d--) {
+      throw new TomlError("document contains excessively nested structures. aborting.", {
+        toml: ctx.s,
+        ptr
+      });
+    }
+    let value = c === 91 ? parseArray(ctx, integersAsBigInt) : parseInlineTable(ctx, integersAsBigInt);
+    ctx.d++;
+    return value;
+  }
+  if (c === 34 || c === 39) {
+    return parseString(ctx);
+  }
+  if (c === 116) {
+    if (ctx.s.charCodeAt(++ctx.p) !== 114 || ctx.s.charCodeAt(++ctx.p) !== 117 || ctx.s.charCodeAt(++ctx.p) !== 101)
+      throw new TomlError("invalid value", { toml: ctx.s, ptr });
+    ctx.p++;
+    return true;
+  }
+  if (c === 102) {
+    if (ctx.s.charCodeAt(++ctx.p) !== 97 || ctx.s.charCodeAt(++ctx.p) !== 108 || ctx.s.charCodeAt(++ctx.p) !== 115 || ctx.s.charCodeAt(++ctx.p) !== 101)
+      throw new TomlError("invalid value", { toml: ctx.s, ptr });
+    ctx.p++;
+    return false;
+  }
+  return parseValue(ctx, integersAsBigInt, end);
+}
+
+// node_modules/smol-toml/dist/struct.js
+var KEY_PART_RE = /^[a-zA-Z0-9-_]+[ \t]*$/;
+function parseKey(ctx, end = "=") {
+  let start = ctx.p;
+  let dot = start - 1;
+  let parsed = [];
+  let endPtr = ctx.s.indexOf(end, start);
+  if (endPtr < 0) {
+    throw new TomlError("incomplete key-value: cannot find end of key", {
+      toml: ctx.s,
+      ptr: start
+    });
+  }
+  do {
+    let c = ctx.s.charCodeAt(ctx.p = ++dot);
+    if (c !== 32 && c !== 9) {
+      if (c === 34 || c === 39) {
+        if (c === ctx.s.charCodeAt(ctx.p + 1) && c === ctx.s.charCodeAt(ctx.p + 2)) {
+          throw new TomlError("multiline strings are not allowed in keys", {
+            toml: ctx.s,
+            ptr: ctx.p
+          });
+        }
+        let part = parseString(ctx);
+        dot = ctx.s.indexOf(".", ctx.p);
+        let strEnd = ctx.s.slice(ctx.p, dot < 0 || dot > endPtr ? endPtr : dot);
+        let newLine = indexOfNewline(strEnd);
+        if (newLine > -1) {
+          throw new TomlError("newlines are not allowed in keys", {
+            toml: ctx.s,
+            ptr: newLine
+          });
+        }
+        if (strEnd.trimStart()) {
+          throw new TomlError("found extra tokens after the string part", {
+            toml: ctx.s,
+            ptr: ctx.p
+          });
+        }
+        if (endPtr < ctx.p) {
+          endPtr = ctx.s.indexOf(end, ctx.p);
+          if (endPtr < 0) {
+            throw new TomlError("incomplete key-value: cannot find end of key", {
+              toml: ctx.s,
+              ptr: start
+            });
+          }
+        }
+        parsed.push(part);
+      } else {
+        dot = ctx.s.indexOf(".", ctx.p);
+        let part = ctx.s.slice(ctx.p, dot < 0 || dot > endPtr ? endPtr : dot);
+        if (!KEY_PART_RE.test(part)) {
+          throw new TomlError("only letter, numbers, dashes and underscores are allowed in keys", {
+            toml: ctx.s,
+            ptr: ctx.p
+          });
+        }
+        parsed.push(part.trimEnd());
+      }
+    }
+  } while (dot + 1 && dot < endPtr);
+  ctx.p = endPtr + 1;
+  skipVoid(ctx, true, true);
+  return parsed;
+}
+function parseInlineTable(ctx, integersAsBigInt) {
+  let res = {};
+  let seen = /* @__PURE__ */ new Set();
+  let c;
+  ctx.p++;
+  while (ctx.p < ctx.s.length) {
+    skipVoid(ctx);
+    if ((c = ctx.s.charCodeAt(ctx.p)) === 125) {
+      ctx.p++;
+      return res;
+    }
+    let k;
+    let t = res;
+    let hasOwn = false;
+    let p = ctx.p;
+    let key = parseKey(ctx);
+    for (let i = 0; i < key.length; i++) {
+      if (i)
+        t = hasOwn ? t[k] : t[k] = {};
+      k = key[i];
+      if ((hasOwn = Object.hasOwn(t, k)) && (typeof t[k] !== "object" || seen.has(t[k]))) {
+        throw new TomlError("trying to redefine an already defined value", {
+          toml: ctx.s,
+          ptr: p
+        });
+      }
+      if (!hasOwn && k === "__proto__") {
+        Object.defineProperty(t, k, { enumerable: true, configurable: true, writable: true });
+      }
+    }
+    if (hasOwn) {
+      throw new TomlError("trying to redefine an already defined value", {
+        toml: ctx.s,
+        ptr: ctx.p
+      });
+    }
+    let value = extractValue(ctx, 125, integersAsBigInt);
+    seen.add(t[k] = value);
+    skipVoid(ctx);
+    if ((c = ctx.s.charCodeAt(ctx.p++)) === 125) {
+      return res;
+    }
+    if (c !== 44) {
+      throw new TomlError("expected comma or end of structure", { toml: ctx.s, ptr: ctx.p - 1 });
+    }
+  }
+  throw new TomlError("unfinished table encountered", {
+    toml: ctx.s,
+    ptr: ctx.p
+  });
+}
+function parseArray(ctx, integersAsBigInt) {
+  let res = [];
+  let c;
+  ctx.p++;
+  while (ctx.p < ctx.s.length) {
+    skipVoid(ctx);
+    if ((c = ctx.s.charCodeAt(ctx.p)) === 93) {
+      ctx.p++;
+      return res;
+    }
+    res.push(extractValue(ctx, 93, integersAsBigInt));
+    skipVoid(ctx);
+    if ((c = ctx.s.charCodeAt(ctx.p++)) === 93) {
+      return res;
+    }
+    if (c !== 44) {
+      throw new TomlError("expected comma or end of structure", { toml: ctx.s, ptr: ctx.p - 1 });
+    }
+  }
+  throw new TomlError("unfinished array encountered", {
+    toml: ctx.s,
+    ptr: ctx.p
+  });
+}
+
+// node_modules/smol-toml/dist/parse.js
+function peekTable(key, table, meta, type) {
+  let t = table;
+  let m = meta;
+  let k;
+  let hasOwn = false;
+  let state;
+  for (let i = 0; i < key.length; i++) {
+    if (i) {
+      t = hasOwn ? t[k] : t[k] = {};
+      m = (state = m[k]).c;
+      if (type === 0 && (state.t === 1 || state.t === 2)) {
+        return null;
+      }
+      if (state.t === 2) {
+        let l = t.length - 1;
+        t = t[l];
+        m = m[l].c;
+      }
+    }
+    k = key[i];
+    if ((hasOwn = Object.hasOwn(t, k)) && m[k]?.t === 0 && m[k]?.d) {
+      return null;
+    }
+    if (!hasOwn) {
+      if (k === "__proto__") {
+        Object.defineProperty(t, k, { enumerable: true, configurable: true, writable: true });
+        Object.defineProperty(m, k, { enumerable: true, configurable: true, writable: true });
+      }
+      m[k] = {
+        t: i < key.length - 1 && type === 2 ? 3 : type,
+        d: false,
+        i: 0,
+        c: {}
+      };
+    }
+  }
+  state = m[k];
+  if (state.t !== type && !(type === 1 && state.t === 3)) {
+    return null;
+  }
+  if (type === 2) {
+    if (!state.d) {
+      state.d = true;
+      t[k] = [];
+    }
+    t[k].push(t = {});
+    state.c[state.i++] = state = { t: 1, d: false, i: 0, c: {} };
+  }
+  if (state.d) {
+    return null;
+  }
+  state.d = true;
+  if (type === 1) {
+    t = hasOwn ? t[k] : t[k] = {};
+  } else if (type === 0 && hasOwn) {
+    return null;
+  }
+  return [k, t, state.c];
+}
+function parse(toml, { maxDepth = 1e3, integersAsBigInt } = {}) {
+  let ctx = { s: toml, p: 0, d: maxDepth };
+  let res = {};
+  let meta = {};
+  let tmp;
+  let tbl = res;
+  let m = meta;
+  skipVoid(ctx);
+  while (ctx.p < toml.length) {
+    if (toml.charCodeAt(ctx.p) === 91) {
+      let isTableArray = toml.charCodeAt(++ctx.p) === 91;
+      tmp = ctx.p += +isTableArray;
+      let k = parseKey(ctx, "]");
+      if (isTableArray) {
+        if (toml.charCodeAt(ctx.p - 1) !== 93) {
+          throw new TomlError("expected end of table declaration", {
+            toml,
+            ptr: ctx.p - 1
+          });
+        }
+        ctx.p++;
+      }
+      let p = peekTable(
+        k,
+        res,
+        meta,
+        isTableArray ? 2 : 1
+        /* Type.EXPLICIT */
+      );
+      if (!p) {
+        throw new TomlError("trying to redefine an already defined table or value", {
+          toml,
+          ptr: tmp
+        });
+      }
+      m = p[2];
+      tbl = p[1];
+    } else {
+      tmp = ctx.p;
+      let k = parseKey(ctx);
+      let p = peekTable(
+        k,
+        tbl,
+        m,
+        0
+        /* Type.DOTTED */
+      );
+      if (!p) {
+        throw new TomlError("trying to redefine an already defined table or value", {
+          toml,
+          ptr: tmp
+        });
+      }
+      p[1][p[0]] = extractValue(ctx, void 0, integersAsBigInt);
+    }
+    skipVoid(ctx, true);
+    if (ctx.p < toml.length && (tmp = toml.charCodeAt(ctx.p)) !== 10 && tmp !== 13) {
+      throw new TomlError("each key-value declaration must be followed by an end-of-line", {
+        toml,
+        ptr: ctx.p
+      });
+    }
+    skipVoid(ctx);
+  }
+  return res;
+}
+
+// node_modules/smol-toml/dist/stringify.js
+init_define_import_meta_env();
+var BARE_KEY = /^[a-z0-9-_]+$/i;
+function extendedTypeOf(obj) {
+  let type = typeof obj;
+  if (type === "object") {
+    if (Array.isArray(obj))
+      return "array";
+    if (typeof obj?.getUTCDate === "function" && obj instanceof Date)
+      return "date";
+    if (globalThis.Temporal && // check for the 'since' property as an early bailout that avoids running all 5 instanceof checks
+    typeof obj?.since === "function" && (obj instanceof Temporal.Instant || obj instanceof Temporal.PlainDate || obj instanceof Temporal.PlainDateTime || obj instanceof Temporal.PlainTime || obj instanceof Temporal.ZonedDateTime)) {
+      return "temporal";
+    }
+  }
+  return type;
+}
+function isArrayOfTables(obj) {
+  for (let i = 0; i < obj.length; i++) {
+    if (extendedTypeOf(obj[i]) !== "object")
+      return false;
+  }
+  return obj.length != 0;
+}
+function formatString(s) {
+  return JSON.stringify(s).replace(/\x7f/g, "\\u007f");
+}
+function stringifyTemporal(temporal) {
+  return temporal.toString({
+    calendarName: "never",
+    timeZoneName: "never"
+  });
+}
+function stringifyValue(val, type, depth, numberAsFloat) {
+  if (depth === 0) {
+    throw new Error("Could not stringify the object: maximum object depth exceeded");
+  }
+  switch (type) {
+    // @ts-expect-error -- intentional fallthrough case
+    case "number":
+      if (isNaN(val))
+        return "nan";
+      if (val === Infinity)
+        return "inf";
+      if (val === -Infinity)
+        return "-inf";
+      if (Number.isInteger(val) && (numberAsFloat || !Number.isSafeInteger(val)))
+        return val.toFixed(1);
+    case "bigint":
+    case "boolean":
+      return val.toString();
+    case "string":
+      return formatString(val);
+    case "date":
+      if (isNaN(val.getTime()))
+        throw new TypeError("cannot serialize invalid date");
+      return val.toISOString();
+    case "object":
+      return stringifyInlineTable(val, depth, numberAsFloat);
+    case "array":
+      return stringifyArray(val, depth, numberAsFloat);
+    case "temporal":
+      return stringifyTemporal(val);
+  }
+}
+function stringifyInlineTable(obj, depth, numberAsFloat) {
+  let keys = Object.keys(obj);
+  if (keys.length === 0)
+    return "{}";
+  let res = "{ ";
+  for (let i = 0; i < keys.length; i++) {
+    let k = keys[i];
+    if (i)
+      res += ", ";
+    res += BARE_KEY.test(k) ? k : formatString(k);
+    res += " = ";
+    res += stringifyValue(obj[k], extendedTypeOf(obj[k]), depth - 1, numberAsFloat);
+  }
+  return res + " }";
+}
+function stringifyArray(array, depth, numberAsFloat) {
+  if (array.length === 0)
+    return "[]";
+  let res = "[ ";
+  for (let i = 0; i < array.length; i++) {
+    if (i)
+      res += ", ";
+    if (array[i] === null || array[i] === void 0) {
+      throw new TypeError("arrays cannot contain null or undefined values");
+    }
+    res += stringifyValue(array[i], extendedTypeOf(array[i]), depth - 1, numberAsFloat);
+  }
+  return res + " ]";
+}
+function stringifyArrayTable(array, key, depth, numberAsFloat) {
+  if (depth === 0) {
+    throw new Error("Could not stringify the object: maximum object depth exceeded");
+  }
+  let res = "";
+  for (let i = 0; i < array.length; i++) {
+    res += `${res && "\n"}[[${key}]]
+`;
+    res += stringifyTable(0, array[i], key, depth, numberAsFloat);
+  }
+  return res;
+}
+function stringifyTable(tableKey, obj, prefix, depth, numberAsFloat) {
+  if (depth === 0) {
+    throw new Error("Could not stringify the object: maximum object depth exceeded");
+  }
+  let preamble = "";
+  let tables = "";
+  let keys = Object.keys(obj);
+  for (let i = 0; i < keys.length; i++) {
+    let k = keys[i];
+    if (obj[k] !== null && obj[k] !== void 0) {
+      let type = extendedTypeOf(obj[k]);
+      if (type === "symbol" || type === "function") {
+        throw new TypeError(`cannot serialize values of type '${type}'`);
+      }
+      let key = BARE_KEY.test(k) ? k : formatString(k);
+      if (type === "array" && isArrayOfTables(obj[k])) {
+        tables += (tables && "\n") + stringifyArrayTable(obj[k], prefix ? `${prefix}.${key}` : key, depth - 1, numberAsFloat);
+      } else if (type === "object") {
+        let tblKey = prefix ? `${prefix}.${key}` : key;
+        tables += (tables && "\n") + stringifyTable(tblKey, obj[k], tblKey, depth - 1, numberAsFloat);
+      } else {
+        preamble += key;
+        preamble += " = ";
+        preamble += stringifyValue(obj[k], type, depth, numberAsFloat);
+        preamble += "\n";
+      }
+    }
+  }
+  if (tableKey && (preamble || !tables))
+    preamble = preamble ? `[${tableKey}]
+${preamble}` : `[${tableKey}]`;
+  return preamble && tables ? `${preamble}
+${tables}` : preamble || tables;
+}
+function stringify(obj, { maxDepth = 1e3, numbersAsFloat = false } = {}) {
+  if (extendedTypeOf(obj) !== "object") {
+    throw new TypeError("stringify can only be called with an object");
+  }
+  let str = stringifyTable(0, obj, "", maxDepth, numbersAsFloat);
+  if (str[str.length - 1] !== "\n")
+    return str + "\n";
+  return str;
+}
+
+// src/config_project.ts
+var PROJECT_LOCKED_SECTIONS = [
+  "injection",
+  "webfetch",
+  "gdrive",
+  "redaction",
+  "mcp",
+  "network",
+  "screenshot"
+];
+var PROJECT_LOCKED_KEYS = [
+  // A repository must not be able to decide how much of its own source an agent gets to see. Turning this on folds function bodies out of every Read of this project's files, so a checked-in `.token-goat.toml` setting it true would shrink what a reviewing agent is shown of the very code it came to review -- and the fold is silent about intent, so it reads as normal output. The user's own global config and TOKEN_GOAT_FOLD_CODE_BODIES still set it freely; only the project-supplied layer is refused.
+  "hints.fold_code_bodies",
+  // Same reasoning as the body fold above, on the comments rather than the code: a checked-in project file must not be able to fold a repository's own explanatory comments out of what a reviewing agent is shown, which is precisely where an intent that disagrees with the code would be written down. The user's global config and TOKEN_GOAT_FOLD_COMMENT_BLOCKS still set it freely.
+  "hints.fold_comment_blocks",
+  // Same reasoning one document over: a repository must not be able to fold its own README or changelog out of what a reviewing agent is shown. The user's global config and TOKEN_GOAT_FOLD_PROSE_PARAGRAPHS still set it freely.
+  "hints.fold_prose_paragraphs",
+  // Same reasoning again: a repository must not be able to hide its own documentation's structure from a reviewing agent by disabling the heading-tree replacement, nor -- more to the point here -- by leaving it on to shrink what a reviewing agent sees of a doc the repo itself ships. The user's global config and TOKEN_GOAT_OUTLINE_LARGE_DOCUMENTS still set it freely.
+  "hints.outline_large_documents",
+  // Same reasoning one file type over: a repository must not be able to decide, from its own checked-in config, how much of its source a reviewing agent is shown -- neither by turning the skeleton off to bury a declaration in a wall of bodies, nor by leaving it on to withhold the bodies themselves. The user's global config and TOKEN_GOAT_SKELETON_LARGE_SOURCES still set it freely.
+  "hints.skeleton_large_sources",
+  // The widest blast radius of anything on this list. The fold keys above decide how much of a file an agent is shown; this decides how much of the whole session survives compaction. A checked-in `.token-goat.toml` setting it to a handful of characters would ask the summarizer to discard the session's accumulated state at every compaction boundary, and the loss is silent -- what comes back is a well-formed short summary, not an error. The user's own global config still sets it freely; only the project-supplied layer is refused.
+  "compact_assist.summary_budget_chars",
+  "image_shrink.max_image_pixels",
+  // The same principle as the four fold keys above, applied one layer earlier and with a wider blast radius: those decide how much of an indexed file is shown, these decide whether it is indexed at all. A checked-in `.token-goat.toml` adding its own attack surface to `skip_dirs` -- or dropping `large_file_skip_kb` to a handful of kilobytes -- removes those files from `symbol`, `read`, `refs`, `semantic` and `graph` for a reviewing agent, and every one of them then answers "not found" in the same words it uses for a name that genuinely does not exist. There is no notice to read, because from the index's point of view nothing was hidden. The user's own global config still sets all three freely; only the project-supplied layer is refused.
+  "indexing.skip_dirs",
+  "indexing.skip_files",
+  "indexing.large_file_skip_kb",
+  "indexing.large_file_symbol_only_kb",
+  "indexing.cross_project_symbols",
+  "worker.blocked_roots"
+];
+var _lastProjectConfigLockedKeys = [];
+function lastProjectConfigLockedKeys() {
+  return _lastProjectConfigLockedKeys;
+}
+function setLastProjectConfigLockedKeys(keys) {
+  _lastProjectConfigLockedKeys = keys;
+}
+function resetLastProjectConfigLockedKeys() {
+  _lastProjectConfigLockedKeys = [];
+}
+function stripLockedProjectKeys(projectRaw) {
+  const cleaned = {};
+  const dropped = [];
+  for (const [section2, value] of Object.entries(projectRaw)) {
+    if (PROJECT_LOCKED_SECTIONS.includes(section2)) {
+      dropped.push(section2);
+      continue;
+    }
+    if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+      const kept = {};
+      for (const [key, keyValue] of Object.entries(value)) {
+        if (PROJECT_LOCKED_KEYS.includes(`${section2}.${key}`)) dropped.push(`${section2}.${key}`);
+        else kept[key] = keyValue;
+      }
+      cleaned[section2] = kept;
+      continue;
+    }
+    cleaned[section2] = value;
+  }
+  return { cleaned, dropped };
+}
+function flattenRawKeys(raw) {
+  const keys = [];
+  for (const [sectionName, val] of Object.entries(raw)) {
+    if (val !== null && typeof val === "object" && !Array.isArray(val)) {
+      for (const sub of Object.keys(val)) {
+        keys.push(`${sectionName}.${sub}`);
+      }
+    } else {
+      keys.push(sectionName);
+    }
+  }
+  return keys;
+}
+function flattenRawValues(raw) {
+  const out = {};
+  for (const [sectionName, val] of Object.entries(raw)) {
+    if (val !== null && typeof val === "object" && !Array.isArray(val)) {
+      for (const [sub, v] of Object.entries(val)) {
+        out[`${sectionName}.${sub}`] = v;
+      }
+    } else {
+      out[sectionName] = val;
+    }
+  }
+  return out;
+}
+function readConfigSource(p) {
+  return decodeSource(fs3.readFileSync(p));
+}
+function readConfigToml(p) {
+  try {
+    return { raw: parse(readConfigSource(p)), parseError: null };
+  } catch (e) {
+    const code = e.code;
+    if (code === "ENOENT") return { raw: {}, parseError: null };
+    return { raw: {}, parseError: extractErrorMessage(e) };
+  }
+}
+function readConfigText(p) {
+  try {
+    return { text: readConfigSource(p), readError: null };
+  } catch (e) {
+    const code = e.code;
+    if (code === "ENOENT") return { text: null, readError: null };
+    return { text: null, readError: extractErrorMessage(e) };
+  }
+}
+function mergeRawConfig(base, override) {
+  const merged = { ...base };
+  for (const [key, overrideVal] of Object.entries(override)) {
+    if (overrideVal !== null && typeof overrideVal === "object" && !Array.isArray(overrideVal)) {
+      const baseVal = base[key];
+      const baseSection = baseVal !== null && typeof baseVal === "object" && !Array.isArray(baseVal) ? baseVal : {};
+      merged[key] = { ...baseSection, ...overrideVal };
+    } else {
+      const baseVal = base[key];
+      if (baseVal !== null && typeof baseVal === "object" && !Array.isArray(baseVal)) continue;
+      merged[key] = overrideVal;
+    }
+  }
+  return merged;
+}
+var _projectRootCache = null;
+function resolveConfigProjectRoot() {
+  const cwd = process.cwd();
+  if (_projectRootCache !== null && _projectRootCache.cwd === cwd) return _projectRootCache.root;
+  const project = findProject(cwd);
+  const root = project !== null ? project.root : cwd;
+  _projectRootCache = { cwd, root };
+  return root;
+}
+registerReset(() => {
+  _projectRootCache = null;
+});
+function getProjectConfigInfo(projectRoot) {
+  const root = projectRoot ?? resolveConfigProjectRoot();
+  const p = projectConfigPath(root);
+  if (!fs3.existsSync(p)) return null;
+  const { raw, parseError } = readConfigToml(p);
+  if (parseError !== null) return { path: p, keys: [], values: {}, parseError };
+  return { path: p, keys: flattenRawKeys(raw), values: flattenRawValues(raw), parseError };
+}
+function isAutoTriggerMultiplierExplicit() {
+  const setsMultiplier = (text) => {
+    const raw = parse(text);
+    const ca_raw = raw["compact_assist"];
+    if (ca_raw === null || typeof ca_raw !== "object" || Array.isArray(ca_raw)) {
+      return false;
+    }
+    return ca_raw["auto_trigger_multiplier"] !== void 0;
+  };
+  try {
+    if (setsMultiplier(readConfigSource(configPath()))) return true;
+  } catch {
+  }
+  try {
+    return setsMultiplier(readConfigSource(projectConfigPath(resolveConfigProjectRoot())));
+  } catch {
+    return false;
+  }
+}
+
+// src/config.ts
+init_define_import_meta_env();
+import * as path2 from "node:path";
+
+// src/config_types.ts
+init_define_import_meta_env();
+
+// src/config_defaults.ts
+init_define_import_meta_env();
+var CONFIG_DEFAULTS = {
+  compact_assist: {
+    enabled: true,
+    triggers: ["manual", "auto"],
+    min_events: 3,
+    max_manifest_tokens: 400,
+    auto_trigger_multiplier: 2,
+    compact_skip_ttl_secs: 300,
+    noise_floor_tokens: 0,
+    edited_dir_group_threshold: 3,
+    max_section_lines: 0,
+    wide_session_threshold: 15,
+    orchestrator_commit_threshold: 5,
+    max_manifest_chars: 1600,
+    summary_budget_chars: 24e3,
+    harness: "auto"
+  },
+  bash_compress: {
+    enabled: true,
+    disabled_filters: [],
+    max_lines: 1e3,
+    max_bytes: 64 * 1024,
+    timeout_seconds: 600,
+    // Matches the hardcoded MIN_CACHE_BYTES floor hooks_bash.ts used before this
+    // knob was wired to a real consumer, so untouched-config installs see no
+    // behavior change now that hooks_bash.ts reads this value instead.
+    cache_min_bytes: 512,
+    cache_max_file_count: 4096,
+    cache_max_bytes: 16 * 1024 * 1024,
+    cache_max_bytes_per_output: 50 * 1024 * 1024,
+    // Measured against the filter test-fixture corpus (424 apply() calls, 298 with
+    // bytesSaved > 0): net-of-marker savings (bytesSaved - ~70-79B marker cost) is
+    // <= 0 for 130/298 (44%) of "compressed" results and <= 100 for 170/298 (57%),
+    // while the real-win half sits at p75=393B / p90=952B net. 100 kills the
+    // marker-doesn't-even-pay-for-itself tier without touching genuine wins.
+    min_net_savings_bytes: 100,
+    // Extends the per-file already-served elision (which only reaches cat/head/tail/sed/awk-shaped reads) to every other Bash command's output -- npm test, git, rg, build runs -- matched against a session-wide served-output list instead of a per-file one. On by default: it goes through the same isRewriteWorthwhile net-benefit gate as every other rewrite here, so it never ships a notice that costs more than the lines it withholds.
+    elide_served_shell_output: true
+  },
+  agent_report: {
+    // Well above the ~2,220 char/call average measured from real claude-skills session transcripts, so only genuine outlier reports are touched. Preserves the hardcoded AGENT_RESULT_CACHE_MIN_BYTES this replaced, so untouched-config installs see no behavior change.
+    min_bytes: 8e3,
+    fence_collapse_min_lines: 20,
+    fence_collapse_keep_lines: 6
+  },
+  bash_diff: {
+    max_hunks_per_file: 10
+  },
+  bash_severity_log: {
+    context_lines: 3,
+    score_threshold: 0.5
+  },
+  post_read_code_compress: {
+    min_lines: 200
+  },
+  session_brief: {
+    enabled: true
+  },
+  skill_preservation: {
+    enabled: true,
+    max_cache_bytes: 5 * 1024 * 1024,
+    orphan_sweep_enabled: true,
+    orphan_age_secs: 604800,
+    truncation_budget_tokens: 800,
+    compress_bodies: true,
+    compress_min_bytes: 16 * 1024,
+    inline_snippets: true,
+    pre_skill_enabled: true,
+    first_load_compact: false,
+    post_compact_full_loads: false
+  },
+  image_shrink: {
+    enabled: true,
+    jpeg_quality: 75,
+    max_image_pixels: 16e6,
+    screenshot_redirect: true,
+    ocr_enabled: true,
+    // Confidence is Tesseract's own 0-100 mean-word-confidence score. 65 is a deliberately
+    // conservative floor: a real screenshot of terminal/code/prose text routinely scores
+    // 85+, while a photo with an incidental sign or logo in frame scores much lower and
+    // noisier -- padding the threshold below the terminal/code norm still comfortably
+    // excludes photographic false positives without needing a second heuristic.
+    ocr_min_confidence: 65,
+    ocr_lang: DEFAULT_OCR_LANG,
+    // Which resolution tier the model being shown the image is on, which decides what its pixels
+    // cost. 'standard' (1568px long edge, 1568 visual tokens) is every model before Claude 4.7;
+    // 'high' (2576px, 4784 tokens) is 4.7 and later, and bills the same large image up to roughly
+    // three times higher. Only the saving *reported* by `token-goat stats` depends on this -- no
+    // image is encoded differently -- and 'standard' is the default because it is the floor: it
+    // caps the counterfactual at the smaller of the two bills and so can never credit a saving
+    // that was not there. Set it to 'high' on a Claude 4.7+ model to see the larger real figure.
+    vision_tier: "standard"
+  },
+  screenshot: {
+    chrome_path: "",
+    block_private_targets: true
+  },
+  repomap: {
+    compact_file_threshold: 50,
+    exclude_tests: true
+  },
+  overflow_guard: {
+    enabled: true,
+    max_tokens: 25e3
+  },
+  stats: {
+    record_zero_savings: false
+  },
+  hints: {
+    quiet_hours: "",
+    json_sidecar: false,
+    min_file_lines_for_hint: 0,
+    bash_dedup_min_bytes: 200,
+    web_dedup_min_bytes: 200,
+    grep_dedup_min_matches: 5,
+    glob_dedup_min_matches: 5,
+    // Existing on-disk file must have at least this many lines before a Write rewrite is even
+    // considered -- rewriting a small file whole is fine, so hooks_write.ts's detector skips
+    // comparison entirely below this floor rather than firing on trivial files.
+    write_rewrite_min_lines: 40,
+    // Minimum percentage of the existing file's lines that must survive unchanged (by LCS) in
+    // the incoming Write content for hooks_write.ts to advise Edit instead. High by design: this
+    // is only meant to catch the "mostly untouched, a few lines changed" case, not a genuine
+    // rewrite that happens to share some boilerplate.
+    write_rewrite_unchanged_pct: 75,
+    serve_diff_on_reread: true,
+    elide_served_lines: true,
+    subagent_markdown_first_read_deny: false,
+    backoff_thresholds: [1, 3, 10, 30],
+    git_hint_max_ms: 50,
+    min_session_hint_savings_bytes: 512,
+    pre_skill_advisory: true,
+    context_threshold_advisory: true,
+    diff_hint_min_tokens_saved: 1e3,
+    // Base for the pressure-scaled first-read deny gate in hooks_read.ts (large file, never read
+    // before). Matches that gate's long-tuned 500KB threshold at 'cool' context pressure; warm/hot/
+    // critical scale it down from there so the same read gets redirected to a surgical read sooner
+    // once the context window is nearly full.
+    large_read_redirect_bytes: 512e3,
+    reread_deny: true,
+    // Matches hooks_read.ts's previously-hardcoded REREAD_DENY_BYTES (50 * 1024) so wiring this
+    // key up as the real gate for that logic does not silently change default behavior for
+    // existing users -- see the reread_deny/reread_deny_min_bytes fix's commit message.
+    reread_deny_min_bytes: 51200,
+    stable_doc_compacts: true,
+    // On. It has now run. The gate that finds the spans answered only from the index, and the index carried the shipping parser stamp on 46 of 17,952 files, so the lever was very nearly dead in practice: a disk parse of the delivered file is now the fallback, worth +3.0 points of withheld bytes on shell reads with no index at all. The cost side is the one this comment used to call unobservable, and it is observable: joining folds to later reads of the folded symbol scores 62.3% recovery, but the same window measured backwards scores 55.8% and a shuffled pairing scores 24.3%, so the excess attributable to the fold is 6.6 points rather than 62. Unlike every re-read mechanism beside it this rewrites a FIRST look, where the reader has no prior copy to notice an omission against, which is why the notice names the symbol and the command that returns it verbatim.
+    fold_code_bodies: true,
+    // On, and separate from the body fold above because the two do not carry the same risk. A body fold needs symbol spans from the index, so it can cut at the wrong line when the index is stale, and it hides the implementation an agent came to read. A comment fold reads the block boundaries off the delivered text itself, so it cannot be stale and works on the first read of a file the indexer has never seen, which is exactly the surface nothing else here reaches. It keeps the opening two lines of a block of 12 or more, so the summary sentence a reader navigates by survives and only the elaboration is replaced, and it alters the text of no line it keeps, its notice naming the absolute range removed so the recall is exact. Measured across this project's own 259 source files it removes 8.07% of the delivered bytes over 420 folds in 170 files. The nearest published measurement is stronger and cruder: removing docstrings outright cost 3 points of resolution rate on SWE-bench Verified for 22% of the tokens (arXiv:2606.01326), and keeping the opening summary is the gentler trade on that curve.
+    fold_comment_blocks: true,
+    // On. It has now run: measured over 2,032 real document reads it removes 43.4% of the pool and 57.4% of the reads it touches, keeping every heading, table, block quote and fenced line, and replacing only the tail of a paragraph whose opening sentence is already a complete one. The recall it needs is a ranged Read of the single line named in the notice, which costs one call and is printed at the point of the cut rather than left for the reader to work out. The project-config lock below stays regardless of this default: a repository still cannot set this key, so the choice to fold is the reader's environment and never the code being read.
+    fold_prose_paragraphs: true,
+    // On. Fires on an untargeted (no offset/limit) Read of a markdown document at least 8,000 bytes with at least 6 headings, replacing the delivered body with a heading tree plus the document preamble when that replacement is meaningfully smaller. Built from the delivered text itself, never the index, so it works on a document the indexer has never seen. Measured over 5,104 real session transcripts (13,870 Read deliveries, 130,249,204 bytes): untargeted markdown reads with >=6 headings at this 8,000-byte floor withhold 41.03% of all Read bytes, within 1.8 points of the best floor tried (2,000 B) while firing far less often on small documents where the interruption is least worth it.
+    outline_large_documents: true,
+    // On. The source-code sibling of outline_large_documents directly above, and gated the same way: an untargeted (no offset/limit) Read of a tree-sitter language at least 12,000 bytes with at least 8 symbols is replaced by its structural skeleton, the preamble plus one declaration line per symbol, with each withheld run named and pointed at the command that returns it. Symbols come from tree-sitter over the delivered text, never the index and never the regex extractors, so a partial symbol list turns the fold off rather than shipping a skeleton missing declarations nothing signals. Measured over 5,104 real session transcripts (130,325,670 delivered Read bytes): 558 reads clear this floor, and the fold withholds 11,241,796 B, 8.63% of all Read bytes.
+    skeleton_large_sources: true,
+    truncated_read_min_lines: 200,
+    protect_recent_reads: 4,
+    warn_unbalanced_shell_quoting: true,
+    prompt_triggers: [],
+    log_large_file_hint_outcomes: false,
+    cross_session_read_dedup: false,
+    cross_session_read_dedup_ttl_secs: 2700,
+    mcp_dedup_ttl_secs: 45,
+    session_start_reminder: true
+  },
+  hooks: {
+    watchdog_ms: 700
+  },
+  webfetch: {
+    allow: [],
+    deny: [],
+    max_file_count: 4096,
+    max_bytes: 32 * 1024 * 1024,
+    compress_bodies: true,
+    compress_min_bytes: 16 * 1024
+  },
+  worker: {
+    blocked_roots: [],
+    max_pool_workers: 4,
+    // 4, not 2. Measured on a 26-core Windows host with a foreground CPU probe: at `priority`
+    // below_normal, 2, 4 and 6 threads are all indistinguishable from an idle machine, including
+    // when the indexer and the probe are pinned to the same 4 cores, and including 4 threads pinned
+    // to 2 cores, which is genuine oversubscription. The same probe reads -10% at 16 threads and
+    // -69% with a 292 ms stall at 4 threads on 2 cores once the priority is normal instead. So the
+    // priority below is what keeps the foreground responsive, not this number, and 4 buys a
+    // measured 1.77x on indexing for no foreground cost. It stays a cap rather than tracking the
+    // core count, because where the platform refuses the priority change (some hardened Linux
+    // setups, sandboxes) this is the only thing left holding indexing back.
+    embed_threads: 4,
+    priority: "below_normal"
+  },
+  indexing: {
+    large_file_symbol_only_kb: 500,
+    large_file_skip_kb: 2048,
+    skip_dirs: [],
+    skip_files: ["coverage.json", "coverage-final.json"],
+    embeddings_enabled: true,
+    cross_project_symbols: true
+  },
+  compression: {
+    profile: "auto"
+  },
+  context: {
+    model_window_tokens: 2e5
+  },
+  injection: {
+    enabled: true
+  },
+  gdrive: {
+    enabled: true
+  },
+  redaction: {
+    custom_patterns: [],
+    strict: false
+  },
+  network: {
+    offline: false
+  },
+  mcp: {
+    confine_reads_to_project_root: true,
+    allowed_roots: []
+  },
+  hint_stats: {
+    suppress_threshold_pct: 15,
+    min_sample_size: 5
+  },
+  semantic: {
+    archive_weight: 0.7,
+    docs_weight: 0.92
+  }
+};
+function getDefaultConfig(section2) {
+  return structuredClone(CONFIG_DEFAULTS[section2] ?? {});
+}
+function defaultConfig() {
+  return {
+    compact_assist: getDefaultConfig("compact_assist"),
+    bash_compress: getDefaultConfig("bash_compress"),
+    agent_report: getDefaultConfig("agent_report"),
+    bash_diff: getDefaultConfig("bash_diff"),
+    bash_severity_log: getDefaultConfig("bash_severity_log"),
+    post_read_code_compress: getDefaultConfig("post_read_code_compress"),
+    session_brief: getDefaultConfig("session_brief"),
+    skill_preservation: getDefaultConfig("skill_preservation"),
+    image_shrink: getDefaultConfig("image_shrink"),
+    screenshot: getDefaultConfig("screenshot"),
+    repomap: getDefaultConfig("repomap"),
+    overflow_guard: getDefaultConfig("overflow_guard"),
+    stats: getDefaultConfig("stats"),
+    hints: getDefaultConfig("hints"),
+    hooks: getDefaultConfig("hooks"),
+    webfetch: getDefaultConfig("webfetch"),
+    worker: getDefaultConfig("worker"),
+    indexing: getDefaultConfig("indexing"),
+    compression: getDefaultConfig("compression"),
+    context: getDefaultConfig("context"),
+    injection: getDefaultConfig("injection"),
+    gdrive: getDefaultConfig("gdrive"),
+    redaction: getDefaultConfig("redaction"),
+    network: getDefaultConfig("network"),
+    mcp: getDefaultConfig("mcp"),
+    hint_stats: getDefaultConfig("hint_stats"),
+    semantic: getDefaultConfig("semantic")
+  };
+}
+
+// src/config.ts
+function validatedBool(raw, def) {
+  if (typeof raw === "boolean") return raw;
+  return def;
+}
+function validatedInt(raw, def, min, max) {
+  const n = typeof raw === "number" ? Math.trunc(raw) : def;
+  if (!Number.isFinite(n)) return def;
+  return Math.max(min, Math.min(max, n));
+}
+function validatedFloat(raw, def, min, max) {
+  const n = typeof raw === "number" ? raw : def;
+  if (!Number.isFinite(n)) return def;
+  return Math.max(min, Math.min(max, n));
+}
+function validatedVisionTier(raw, def) {
+  return raw === "standard" || raw === "high" ? raw : def;
+}
+function validatedOcrLang(raw, def) {
+  if (typeof raw !== "string") return def;
+  const tokens = raw.split(/[+,;\s]+/).map((s) => s.trim().toLowerCase()).filter(Boolean);
+  const valid = tokens.filter((t) => isSupportedOcrLang(t));
+  return valid.length > 0 ? valid.join("+") : def;
+}
+function validatedStr(raw, def) {
+  return typeof raw === "string" ? raw : def;
+}
+function validatedStrList(raw, def) {
+  if (!Array.isArray(raw)) return def;
+  return raw.filter((x) => typeof x === "string");
+}
+function validatedIntList(raw, def) {
+  if (!Array.isArray(raw)) return def;
+  return raw.filter((x) => typeof x === "number" && Number.isFinite(x)).map(Math.trunc);
+}
+function validatedIntWithLegacySentinel(raw, def, sentinel, min, max) {
+  return raw === sentinel ? def : validatedInt(raw, def, min, max);
+}
+function section(raw, key) {
+  const val = raw[key];
+  return val !== null && typeof val === "object" && !Array.isArray(val) ? val : {};
+}
+var NUMERIC_FIELD_BOUNDS = {
+  "compact_assist.min_events": { min: 0, max: 1e3 },
+  "compact_assist.max_manifest_tokens": { min: 50, max: 1e4 },
+  "compact_assist.auto_trigger_multiplier": { min: 1, max: 10 },
+  "compact_assist.compact_skip_ttl_secs": { min: 1, max: 3600 },
+  "compact_assist.noise_floor_tokens": { min: 0, max: 1e4 },
+  "compact_assist.edited_dir_group_threshold": { min: 0, max: 100 },
+  "compact_assist.max_section_lines": { min: 0, max: 1e4 },
+  "compact_assist.wide_session_threshold": { min: 1, max: 1e4 },
+  "compact_assist.orchestrator_commit_threshold": { min: 1, max: 1e4 },
+  "compact_assist.max_manifest_chars": { min: 0, max: 16e3 },
+  "compact_assist.summary_budget_chars": { min: 0, max: 2e5 },
+  "bash_compress.max_lines": { min: 50, max: 1e5 },
+  "bash_compress.max_bytes": { min: 1024, max: 16 * 1024 * 1024 },
+  "bash_compress.timeout_seconds": { min: 5, max: 7200 },
+  "bash_compress.cache_min_bytes": { min: 0, max: 100 * 1024 * 1024 },
+  "bash_compress.cache_max_file_count": { min: 1, max: 1e6 },
+  "bash_compress.cache_max_bytes": { min: 1024, max: 4 * 1024 * 1024 * 1024 },
+  "bash_compress.cache_max_bytes_per_output": { min: 1024, max: 4 * 1024 * 1024 * 1024, clampTo: "bash_compress.cache_max_bytes" },
+  "bash_compress.min_net_savings_bytes": { min: 0, max: 1024 * 1024 },
+  "agent_report.min_bytes": { min: 0, max: 100 * 1024 * 1024 },
+  "agent_report.fence_collapse_min_lines": { min: 1, max: 1e5 },
+  // Bounded below the min-lines floor's own minimum is NOT enforceable here (bounds are per-key), so the loader clamps keep_lines against min_lines after both are read -- see the clamp comment there.
+  "agent_report.fence_collapse_keep_lines": { min: 0, max: 1e5 },
+  "bash_diff.max_hunks_per_file": { min: 1, max: 1e4 },
+  "bash_severity_log.context_lines": { min: 0, max: 100 },
+  "bash_severity_log.score_threshold": { min: 0, max: 1 },
+  "post_read_code_compress.min_lines": { min: 0, max: 1e6 },
+  "skill_preservation.max_cache_bytes": { min: 64 * 1024, max: 512 * 1024 * 1024 },
+  "skill_preservation.orphan_age_secs": { min: 1, max: 2592e3 },
+  "skill_preservation.truncation_budget_tokens": { min: 0, max: 8e3 },
+  "skill_preservation.compress_min_bytes": { min: 1024, max: 10 * 1024 * 1024 },
+  "image_shrink.jpeg_quality": { min: 1, max: 100 },
+  "image_shrink.max_image_pixels": { min: 0, max: 1e9 },
+  "image_shrink.ocr_min_confidence": { min: 0, max: 100 },
+  "repomap.compact_file_threshold": { min: 0, max: 1e5 },
+  "overflow_guard.max_tokens": { min: 1e3, max: 1e6 },
+  "hints.min_file_lines_for_hint": { min: 0, max: 1e6 },
+  "hints.bash_dedup_min_bytes": { min: 0, max: 1e5 },
+  "hints.web_dedup_min_bytes": { min: 0, max: 1e5 },
+  "hints.grep_dedup_min_matches": { min: 0, max: 1e5 },
+  "hints.glob_dedup_min_matches": { min: 0, max: 1e5 },
+  "hints.write_rewrite_min_lines": { min: 0, max: 1e6 },
+  "hints.write_rewrite_unchanged_pct": { min: 0, max: 100 },
+  "hints.git_hint_max_ms": { min: 0, max: 1e4 },
+  "hints.min_session_hint_savings_bytes": { min: 0, max: 1e6 },
+  "hints.diff_hint_min_tokens_saved": { min: 0, max: 1e5 },
+  "hints.large_read_redirect_bytes": { min: 0, max: 1e8 },
+  "hints.reread_deny_min_bytes": { min: 0, max: 1e8 },
+  "hints.truncated_read_min_lines": { min: 0, max: 1e6 },
+  "hints.protect_recent_reads": { min: 0, max: 100 },
+  "hints.cross_session_read_dedup_ttl_secs": { min: 1, max: 86400 },
+  "hints.mcp_dedup_ttl_secs": { min: 1, max: 3600 },
+  "hooks.watchdog_ms": { min: 100, max: 3e4 },
+  "webfetch.max_file_count": { min: 0, max: 1e7 },
+  "webfetch.max_bytes": { min: 0, max: 100 * 1024 * 1024 * 1024 },
+  "webfetch.compress_min_bytes": { min: 1024, max: 10 * 1024 * 1024 },
+  "worker.max_pool_workers": { min: 1, max: 8 },
+  "worker.embed_threads": { min: 1, max: 16 },
+  "indexing.large_file_symbol_only_kb": { min: 1, max: 1048576, clampTo: "indexing.large_file_skip_kb" },
+  "indexing.large_file_skip_kb": { min: 1, max: 1048576 },
+  "context.model_window_tokens": { min: 1e4, max: 1e7 },
+  "hint_stats.suppress_threshold_pct": { min: 0, max: 100 },
+  "hint_stats.min_sample_size": { min: 1, max: 1e4 },
+  "semantic.archive_weight": { min: 0.05, max: 1 },
+  "semantic.docs_weight": { min: 0.05, max: 1 }
+};
+function boundsOf(key) {
+  const b = NUMERIC_FIELD_BOUNDS[key];
+  if (!b) throw new Error(`token-goat: no NUMERIC_FIELD_BOUNDS entry for '${key}'`);
+  return [b.min, b.max];
+}
+function walkGetNumeric(obj, parts) {
+  let cur = obj;
+  for (const part of parts) {
+    if (typeof cur !== "object" || cur === null) return void 0;
+    cur = cur[part];
+    if (cur === void 0) return void 0;
+  }
+  return typeof cur === "number" ? cur : void 0;
+}
+function validateNumericField(fieldKey, value, cfg) {
+  const bounds = NUMERIC_FIELD_BOUNDS[fieldKey];
+  if (!bounds) return void 0;
+  let clamped = Math.max(bounds.min, Math.min(bounds.max, value));
+  if (bounds.clampTo) {
+    const clampToValue = walkGetNumeric(cfg, bounds.clampTo.split("."));
+    if (typeof clampToValue === "number") {
+      clamped = Math.min(clamped, clampToValue);
+    }
+  }
+  return clamped;
+}
+var ENUM_FIELD_VALUES = {
+  "compression.profile": ["auto", "aggressive", "balanced", "minimal"],
+  "compact_assist.harness": ["auto", ...KNOWN_HARNESS_NAMES],
+  "image_shrink.ocr_lang": [...SUPPORTED_OCR_LANG_CODES],
+  // Deliberately has no entry above `normal`. This table is what `config set` checks; a
+  // hand-edited TOML bypasses it, which is why resolveWorkerPriority (process_priority.ts) maps an
+  // unrecognized value back to the default rather than trusting whatever the file said.
+  "worker.priority": ["below_normal", "low", "normal"]
+};
+function validateEnumField(fieldKey, value) {
+  if (fieldKey === "image_shrink.ocr_lang") {
+    const tokens = value.split(/[+,;\s]+/).map((s) => s.trim().toLowerCase()).filter(Boolean);
+    const allowed2 = [...SUPPORTED_OCR_LANG_CODES];
+    return tokens.length > 0 && tokens.every((t) => isSupportedOcrLang(t)) ? void 0 : allowed2;
+  }
+  const allowed = ENUM_FIELD_VALUES[fieldKey];
+  if (!allowed) return void 0;
+  return allowed.includes(value) ? void 0 : allowed;
+}
+var ENV_KEYS2 = [
+  "TOKEN_GOAT_COMPACT_ASSIST",
+  "TOKENWISE_COMPACT_ASSIST",
+  "TOKEN_GOAT_BASH_COMPRESS",
+  "TOKEN_GOAT_SESSION_BRIEF",
+  "TOKEN_GOAT_SKILL_PRESERVATION",
+  "TOKEN_GOAT_MAX_IMAGE_PIXELS",
+  "TOKEN_GOAT_OCR_LANG",
+  "TOKEN_GOAT_REPOMAP_COMPACT_THRESHOLD",
+  "TOKEN_GOAT_REPOMAP_EXCLUDE_TESTS",
+  "TOKEN_GOAT_OVERFLOW_GUARD",
+  "TOKEN_GOAT_OVERFLOW_MAX_TOKENS",
+  "TOKEN_GOAT_HINT_JSON_SIDECAR",
+  "TOKEN_GOAT_LARGE_READ_BYTES",
+  "TOKEN_GOAT_HINT_BUDGET",
+  "TOKEN_GOAT_HOOK_WATCHDOG_MS",
+  "TOKEN_GOAT_WEB_COMPRESS",
+  "TOKEN_GOAT_WORKER_WATCHDOG",
+  "TOKEN_GOAT_WORKER_MAX_POOL",
+  "TOKEN_GOAT_COMPRESS_PROFILE",
+  "TOKEN_GOAT_MODEL_WINDOW_TOKENS",
+  "TOKEN_GOAT_INJECTION_ENABLED",
+  "TOKEN_GOAT_MCP_CONFINE_READS",
+  "TOKEN_GOAT_SERVE_DIFF_ON_REREAD",
+  "TOKEN_GOAT_ELIDE_SERVED_LINES",
+  "TOKEN_GOAT_BASH_CACHE_MIN_BYTES",
+  "TOKEN_GOAT_BASH_CACHE_MAX_FILES",
+  "TOKEN_GOAT_BASH_CACHE_MAX_BYTES",
+  "TOKEN_GOAT_BASH_CACHE_MAX_BYTES_PER_OUTPUT",
+  "TOKEN_GOAT_SESSION_HINT_MIN_BYTES",
+  "TOKEN_GOAT_SKILL_COMPRESS",
+  "TOKEN_GOAT_PRE_SKILL",
+  "TOKEN_GOAT_ORPHAN_SWEEP",
+  "TOKEN_GOAT_WARN_UNBALANCED_SHELL_QUOTING",
+  "TOKEN_GOAT_LOG_LARGE_FILE_HINT_OUTCOMES",
+  "TOKEN_GOAT_CROSS_SESSION_READ_DEDUP",
+  "TOKEN_GOAT_CROSS_SESSION_READ_DEDUP_TTL_SECS",
+  "TOKEN_GOAT_MCP_DEDUP_TTL_SECS",
+  "TOKEN_GOAT_EMBEDDINGS_ENABLED",
+  "TOKEN_GOAT_BASH_DEDUP_MIN_BYTES",
+  "TOKEN_GOAT_WEB_DEDUP_MIN_BYTES",
+  "TOKEN_GOAT_GREP_DEDUP_MIN_MATCHES",
+  "TOKEN_GOAT_WEB_CACHE_MAX_FILES",
+  "TOKEN_GOAT_WEB_CACHE_MAX_BYTES",
+  "TOKEN_GOAT_WRITE_REWRITE_MIN_LINES",
+  "TOKEN_GOAT_WRITE_REWRITE_UNCHANGED_PCT"
+];
+function allEnvKeys() {
+  return [.../* @__PURE__ */ new Set([...ENV_KEYS2, ...Object.values(CONFIG_KEY_ENV_OVERRIDES).flat()])];
+}
+function configEnvFingerprint() {
+  const snap = {};
+  for (const k of allEnvKeys()) {
+    snap[k] = process.env[k];
+  }
+  return JSON.stringify(snap);
+}
+var _cached2 = null;
+function deepFreeze(value) {
+  if (value !== null && typeof value === "object" && !Object.isFrozen(value)) {
+    Object.freeze(value);
+    for (const v of Object.values(value)) {
+      deepFreeze(v);
+    }
+  }
+  return value;
+}
+var _lastConfigParseError = null;
+function getLastConfigParseError() {
+  return _lastConfigParseError;
+}
+var _lastProjectConfigParseError = null;
+function getLastProjectConfigParseError() {
+  return _lastProjectConfigParseError;
+}
+function rawValueEquals(a, b) {
+  if (a === b) return true;
+  if (Array.isArray(a) || Array.isArray(b)) {
+    if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false;
+    return a.every((el, i) => rawValueEquals(el, b[i]));
+  }
+  if (typeof a === "object" && typeof b === "object" && a !== null && b !== null) {
+    const ka = Object.keys(a);
+    const kb = Object.keys(b);
+    if (ka.length !== kb.length) return false;
+    return ka.every((k) => Object.prototype.hasOwnProperty.call(b, k) && rawValueEquals(a[k], b[k]));
+  }
+  return false;
+}
+function rejectionReason(key, rawValue, effectiveValue, cfg) {
+  if (typeof rawValue === "number") {
+    const bounds = NUMERIC_FIELD_BOUNDS[key];
+    if (bounds !== void 0) {
+      if (rawValue < bounds.min || rawValue > bounds.max) return `outside the allowed range ${bounds.min}-${bounds.max}`;
+      if (!Number.isInteger(rawValue) && Number.isInteger(effectiveValue)) return "not a whole number";
+      const clamped = validateNumericField(key, rawValue, cfg);
+      if (clamped !== void 0 && clamped !== rawValue && bounds.clampTo !== void 0) return `above ${bounds.clampTo}, which caps it`;
+    }
+    return null;
+  }
+  if (typeof rawValue === "string") {
+    const allowed = validateEnumField(key, rawValue);
+    if (allowed !== void 0) return `not one of: ${allowed.join(", ")}`;
+  }
+  if (effectiveValue !== void 0 && typeof rawValue !== typeof effectiveValue) {
+    return `expected ${Array.isArray(effectiveValue) ? "a list" : `a ${typeof effectiveValue}`}, got ${Array.isArray(rawValue) ? "a list" : `a ${typeof rawValue}`}`;
+  }
+  return null;
+}
+function coerceEnvLike(rawStr, effectiveValue) {
+  const norm = rawStr.trim();
+  if (typeof effectiveValue === "number") {
+    if (norm === "" || !/^[+-]?\d+$/.test(norm)) return "unusable";
+    const val = parseInt(norm, 10);
+    return Number.isFinite(val) ? { parsed: val } : "unusable";
+  }
+  if (typeof effectiveValue === "boolean") {
+    const lower = norm.toLowerCase();
+    if (TRUTHY_ENV_VALUES.has(lower)) return { parsed: true };
+    if (FALSY_ENV_VALUES.has(lower)) return { parsed: false };
+    return "unusable";
+  }
+  if (typeof effectiveValue === "string") {
+    return norm === "" ? "unusable" : { parsed: norm };
+  }
+  return null;
+}
+function resolveConfigKeyLayer(key, effectiveValue, cfg, projectInfo) {
+  const envVar = (CONFIG_KEY_ENV_OVERRIDES[key] ?? []).find((name) => process.env[name] !== void 0);
+  if (envVar !== void 0) {
+    const rawStr = process.env[envVar] ?? "";
+    const judged = coerceEnvLike(rawStr, effectiveValue);
+    if (judged === null) return { layer: "env", envVar };
+    if (judged === "unusable") {
+      return { layer: "env-invalid", envVar, rawValue: rawStr, effectiveValue, reason: rawStr.trim() === "" ? "empty" : rejectionReason(key, rawStr, effectiveValue, cfg) };
+    }
+    if (rawValueEquals(judged.parsed, effectiveValue)) return { layer: "env", envVar };
+    return { layer: "env-invalid", envVar, rawValue: judged.parsed, effectiveValue, reason: rejectionReason(key, judged.parsed, effectiveValue, cfg) };
+  }
+  if (projectInfo === null) return { layer: "global" };
+  if (projectInfo.parseError !== null) return { layer: "project-unparsed", path: projectInfo.path, parseError: projectInfo.parseError };
+  if (!Object.prototype.hasOwnProperty.call(projectInfo.values, key)) return { layer: "global" };
+  const rawValue = projectInfo.values[key];
+  if (rawValueEquals(rawValue, effectiveValue)) return { layer: "project", path: projectInfo.path };
+  return { layer: "project-invalid", path: projectInfo.path, rawValue, effectiveValue, reason: rejectionReason(key, rawValue, effectiveValue, cfg) };
+}
+function loadConfig(projectRoot) {
+  const p = configPath();
+  const root = projectRoot ?? resolveConfigProjectRoot();
+  const projPath = projectConfigPath(root);
+  const { text, readError } = readConfigText(p);
+  const contentFp = text !== null ? shortFingerprint(text) : "";
+  const { text: projText, readError: projReadError } = readConfigText(projPath);
+  const projectContentFp = projText !== null ? shortFingerprint(projText) : "";
+  const envFp = configEnvFingerprint();
+  if (_cached2 !== null && _cached2.contentFp === contentFp && _cached2.envFp === envFp && _cached2.projectRoot === root && _cached2.projectContentFp === projectContentFp) {
+    return _cached2.config;
+  }
+  let raw = {};
+  if (text !== null) {
+    try {
+      raw = parse(text);
+      _lastConfigParseError = null;
+    } catch (e) {
+      _lastConfigParseError = extractErrorMessage(e);
+    }
+  } else {
+    _lastConfigParseError = readError;
+  }
+  let projectRaw = {};
+  if (projText !== null) {
+    try {
+      projectRaw = parse(projText);
+      _lastProjectConfigParseError = null;
+    } catch (e) {
+      _lastProjectConfigParseError = extractErrorMessage(e);
+    }
+  } else {
+    _lastProjectConfigParseError = projReadError;
+  }
+  const cfg = deepFreeze(_buildConfig(raw, projectRaw));
+  _cached2 = { config: cfg, contentFp, envFp, projectRoot: root, projectContentFp };
+  return cfg;
+}
+function invalidateConfigCache() {
+  _cached2 = null;
+  resetLastProjectConfigLockedKeys();
+}
+registerReset(invalidateConfigCache);
+function withoutConfigEnv(fn) {
+  const keys = allEnvKeys();
+  const saved = {};
+  for (const k of keys) {
+    saved[k] = process.env[k];
+    delete process.env[k];
+  }
+  try {
+    return fn();
+  } finally {
+    for (const k of keys) {
+      const v = saved[k];
+      if (v === void 0) delete process.env[k];
+      else process.env[k] = v;
+    }
+  }
+}
+function buildPersistedConfig(raw) {
+  return withoutConfigEnv(() => _buildConfig(raw));
+}
+function loadPersistedConfig() {
+  const p = configPath();
+  const { raw, parseError } = readConfigToml(p);
+  _lastConfigParseError = parseError;
+  return buildPersistedConfig(raw);
+}
+function _buildConfig(raw, projectRaw = {}) {
+  const { cleaned: safeProjectRaw, dropped: lockedKeys } = stripLockedProjectKeys(projectRaw);
+  setLastProjectConfigLockedKeys(lockedKeys);
+  if (Object.keys(safeProjectRaw).length > 0) {
+    raw = mergeRawConfig(raw, safeProjectRaw);
+  }
+  const ca_raw = section(raw, "compact_assist");
+  const ca = getDefaultConfig("compact_assist");
+  ca.enabled = validatedBool(ca_raw["enabled"], ca.enabled);
+  ca.triggers = validatedStrList(ca_raw["triggers"], ca.triggers);
+  ca.min_events = validatedInt(ca_raw["min_events"], ca.min_events, ...boundsOf("compact_assist.min_events"));
+  ca.max_manifest_tokens = validatedInt(ca_raw["max_manifest_tokens"], ca.max_manifest_tokens, ...boundsOf("compact_assist.max_manifest_tokens"));
+  ca.auto_trigger_multiplier = validatedFloat(ca_raw["auto_trigger_multiplier"], ca.auto_trigger_multiplier, ...boundsOf("compact_assist.auto_trigger_multiplier"));
+  ca.compact_skip_ttl_secs = validatedFloat(ca_raw["compact_skip_ttl_secs"], ca.compact_skip_ttl_secs, ...boundsOf("compact_assist.compact_skip_ttl_secs"));
+  ca.noise_floor_tokens = validatedInt(ca_raw["noise_floor_tokens"], ca.noise_floor_tokens, ...boundsOf("compact_assist.noise_floor_tokens"));
+  ca.edited_dir_group_threshold = validatedInt(ca_raw["edited_dir_group_threshold"], ca.edited_dir_group_threshold, ...boundsOf("compact_assist.edited_dir_group_threshold"));
+  ca.max_section_lines = validatedInt(ca_raw["max_section_lines"], ca.max_section_lines, ...boundsOf("compact_assist.max_section_lines"));
+  ca.wide_session_threshold = validatedInt(ca_raw["wide_session_threshold"], ca.wide_session_threshold, ...boundsOf("compact_assist.wide_session_threshold"));
+  ca.orchestrator_commit_threshold = validatedInt(ca_raw["orchestrator_commit_threshold"], ca.orchestrator_commit_threshold, ...boundsOf("compact_assist.orchestrator_commit_threshold"));
+  ca.max_manifest_chars = validatedInt(ca_raw["max_manifest_chars"], ca.max_manifest_chars, ...boundsOf("compact_assist.max_manifest_chars"));
+  ca.summary_budget_chars = validatedInt(ca_raw["summary_budget_chars"], ca.summary_budget_chars, ...boundsOf("compact_assist.summary_budget_chars"));
+  ca.harness = validatedStr(ca_raw["harness"], ca.harness);
+  ca.enabled = envBool("TOKEN_GOAT_COMPACT_ASSIST", envBool("TOKENWISE_COMPACT_ASSIST", ca.enabled));
+  const bc_raw = section(raw, "bash_compress");
+  const bc = getDefaultConfig("bash_compress");
+  bc.enabled = validatedBool(bc_raw["enabled"], bc.enabled);
+  bc.disabled_filters = validatedStrList(bc_raw["disabled_filters"], bc.disabled_filters);
+  bc.max_lines = validatedInt(bc_raw["max_lines"], bc.max_lines, ...boundsOf("bash_compress.max_lines"));
+  bc.max_bytes = validatedInt(bc_raw["max_bytes"], bc.max_bytes, ...boundsOf("bash_compress.max_bytes"));
+  bc.timeout_seconds = validatedInt(bc_raw["timeout_seconds"], bc.timeout_seconds, ...boundsOf("bash_compress.timeout_seconds"));
+  bc.cache_min_bytes = validatedIntWithLegacySentinel(bc_raw["cache_min_bytes"], bc.cache_min_bytes, 0, ...boundsOf("bash_compress.cache_min_bytes"));
+  bc.cache_max_file_count = validatedInt(bc_raw["cache_max_file_count"], bc.cache_max_file_count, ...boundsOf("bash_compress.cache_max_file_count"));
+  bc.cache_max_bytes = validatedInt(bc_raw["cache_max_bytes"], bc.cache_max_bytes, ...boundsOf("bash_compress.cache_max_bytes"));
+  bc.cache_max_bytes_per_output = validatedInt(bc_raw["cache_max_bytes_per_output"], bc.cache_max_bytes_per_output, ...boundsOf("bash_compress.cache_max_bytes_per_output"));
+  bc.min_net_savings_bytes = validatedInt(bc_raw["min_net_savings_bytes"], bc.min_net_savings_bytes, ...boundsOf("bash_compress.min_net_savings_bytes"));
+  bc.elide_served_shell_output = validatedBool(bc_raw["elide_served_shell_output"], bc.elide_served_shell_output);
+  bc.enabled = envBool("TOKEN_GOAT_BASH_COMPRESS", bc.enabled);
+  bc.cache_min_bytes = envInt("TOKEN_GOAT_BASH_CACHE_MIN_BYTES", bc.cache_min_bytes, ...boundsOf("bash_compress.cache_min_bytes"));
+  bc.cache_max_file_count = envInt("TOKEN_GOAT_BASH_CACHE_MAX_FILES", bc.cache_max_file_count, ...boundsOf("bash_compress.cache_max_file_count"));
+  bc.cache_max_bytes = envInt("TOKEN_GOAT_BASH_CACHE_MAX_BYTES", bc.cache_max_bytes, ...boundsOf("bash_compress.cache_max_bytes"));
+  bc.cache_max_bytes_per_output = envInt("TOKEN_GOAT_BASH_CACHE_MAX_BYTES_PER_OUTPUT", bc.cache_max_bytes_per_output, ...boundsOf("bash_compress.cache_max_bytes_per_output"));
+  bc.min_net_savings_bytes = envInt("TOKEN_GOAT_BASH_MIN_NET_SAVINGS_BYTES", bc.min_net_savings_bytes, ...boundsOf("bash_compress.min_net_savings_bytes"));
+  bc.cache_max_bytes_per_output = Math.min(bc.cache_max_bytes_per_output, bc.cache_max_bytes);
+  const ar_raw = section(raw, "agent_report");
+  const ar = getDefaultConfig("agent_report");
+  ar.min_bytes = validatedInt(ar_raw["min_bytes"], ar.min_bytes, ...boundsOf("agent_report.min_bytes"));
+  ar.fence_collapse_min_lines = validatedInt(ar_raw["fence_collapse_min_lines"], ar.fence_collapse_min_lines, ...boundsOf("agent_report.fence_collapse_min_lines"));
+  ar.fence_collapse_keep_lines = validatedInt(ar_raw["fence_collapse_keep_lines"], ar.fence_collapse_keep_lines, ...boundsOf("agent_report.fence_collapse_keep_lines"));
+  ar.min_bytes = envInt("TOKEN_GOAT_AGENT_REPORT_MIN_BYTES", ar.min_bytes, ...boundsOf("agent_report.min_bytes"));
+  ar.fence_collapse_min_lines = envInt("TOKEN_GOAT_AGENT_REPORT_FENCE_MIN_LINES", ar.fence_collapse_min_lines, ...boundsOf("agent_report.fence_collapse_min_lines"));
+  ar.fence_collapse_keep_lines = envInt("TOKEN_GOAT_AGENT_REPORT_FENCE_KEEP_LINES", ar.fence_collapse_keep_lines, ...boundsOf("agent_report.fence_collapse_keep_lines"));
+  ar.fence_collapse_keep_lines = Math.min(ar.fence_collapse_keep_lines, Math.floor((ar.fence_collapse_min_lines - 1) / 2));
+  const bd_raw = section(raw, "bash_diff");
+  const bd = getDefaultConfig("bash_diff");
+  bd.max_hunks_per_file = validatedInt(bd_raw["max_hunks_per_file"], bd.max_hunks_per_file, ...boundsOf("bash_diff.max_hunks_per_file"));
+  const sl_raw = section(raw, "bash_severity_log");
+  const sl = getDefaultConfig("bash_severity_log");
+  sl.context_lines = validatedInt(sl_raw["context_lines"], sl.context_lines, ...boundsOf("bash_severity_log.context_lines"));
+  sl.score_threshold = validatedFloat(sl_raw["score_threshold"], sl.score_threshold, ...boundsOf("bash_severity_log.score_threshold"));
+  const cc_raw = section(raw, "post_read_code_compress");
+  const cc = getDefaultConfig("post_read_code_compress");
+  cc.min_lines = validatedInt(cc_raw["min_lines"], cc.min_lines, ...boundsOf("post_read_code_compress.min_lines"));
+  const sb_raw = section(raw, "session_brief");
+  const sb = getDefaultConfig("session_brief");
+  sb.enabled = validatedBool(sb_raw["enabled"], sb.enabled);
+  sb.enabled = envBool("TOKEN_GOAT_SESSION_BRIEF", sb.enabled);
+  const sp_raw = section(raw, "skill_preservation");
+  const sp = getDefaultConfig("skill_preservation");
+  sp.enabled = validatedBool(sp_raw["enabled"], sp.enabled);
+  sp.max_cache_bytes = validatedInt(sp_raw["max_cache_bytes"], sp.max_cache_bytes, ...boundsOf("skill_preservation.max_cache_bytes"));
+  sp.orphan_sweep_enabled = validatedBool(sp_raw["orphan_sweep_enabled"], sp.orphan_sweep_enabled);
+  sp.orphan_age_secs = validatedInt(sp_raw["orphan_age_secs"], sp.orphan_age_secs, ...boundsOf("skill_preservation.orphan_age_secs"));
+  sp.truncation_budget_tokens = validatedInt(sp_raw["truncation_budget_tokens"], sp.truncation_budget_tokens, ...boundsOf("skill_preservation.truncation_budget_tokens"));
+  sp.compress_bodies = validatedBool(sp_raw["compress_bodies"], sp.compress_bodies);
+  sp.compress_min_bytes = validatedInt(sp_raw["compress_min_bytes"], sp.compress_min_bytes, ...boundsOf("skill_preservation.compress_min_bytes"));
+  sp.inline_snippets = validatedBool(sp_raw["inline_snippets"], sp.inline_snippets);
+  sp.pre_skill_enabled = validatedBool(sp_raw["pre_skill_enabled"], sp.pre_skill_enabled);
+  sp.first_load_compact = validatedBool(sp_raw["first_load_compact"], sp.first_load_compact);
+  sp.post_compact_full_loads = validatedBool(sp_raw["post_compact_full_loads"], sp.post_compact_full_loads);
+  sp.enabled = envBool("TOKEN_GOAT_SKILL_PRESERVATION", sp.enabled);
+  sp.compress_bodies = envBool("TOKEN_GOAT_SKILL_COMPRESS", sp.compress_bodies);
+  sp.pre_skill_enabled = envBool("TOKEN_GOAT_PRE_SKILL", sp.pre_skill_enabled);
+  sp.orphan_sweep_enabled = envBool("TOKEN_GOAT_ORPHAN_SWEEP", sp.orphan_sweep_enabled);
+  const is_raw = section(raw, "image_shrink");
+  const is_cfg = getDefaultConfig("image_shrink");
+  is_cfg.enabled = validatedBool(is_raw["enabled"], is_cfg.enabled);
+  is_cfg.jpeg_quality = validatedInt(is_raw["jpeg_quality"], is_cfg.jpeg_quality, ...boundsOf("image_shrink.jpeg_quality"));
+  is_cfg.max_image_pixels = validatedInt(is_raw["max_image_pixels"], is_cfg.max_image_pixels, ...boundsOf("image_shrink.max_image_pixels"));
+  is_cfg.screenshot_redirect = validatedBool(is_raw["screenshot_redirect"], is_cfg.screenshot_redirect);
+  is_cfg.ocr_enabled = validatedBool(is_raw["ocr_enabled"], is_cfg.ocr_enabled);
+  is_cfg.ocr_min_confidence = validatedInt(is_raw["ocr_min_confidence"], is_cfg.ocr_min_confidence, ...boundsOf("image_shrink.ocr_min_confidence"));
+  is_cfg.ocr_lang = validatedOcrLang(is_raw["ocr_lang"], is_cfg.ocr_lang);
+  is_cfg.vision_tier = validatedVisionTier(is_raw["vision_tier"], is_cfg.vision_tier);
+  is_cfg.max_image_pixels = envInt("TOKEN_GOAT_MAX_IMAGE_PIXELS", is_cfg.max_image_pixels, ...boundsOf("image_shrink.max_image_pixels"));
+  is_cfg.ocr_enabled = envBool("TOKEN_GOAT_OCR_ENABLED", is_cfg.ocr_enabled);
+  is_cfg.ocr_lang = validatedOcrLang(process.env["TOKEN_GOAT_OCR_LANG"], is_cfg.ocr_lang);
+  is_cfg.vision_tier = validatedVisionTier(process.env["TOKEN_GOAT_VISION_TIER"], is_cfg.vision_tier);
+  const sc_raw = section(raw, "screenshot");
+  const sc_cfg = getDefaultConfig("screenshot");
+  sc_cfg.chrome_path = validatedStr(sc_raw["chrome_path"], sc_cfg.chrome_path);
+  sc_cfg.block_private_targets = validatedBool(sc_raw["block_private_targets"], sc_cfg.block_private_targets);
+  sc_cfg.block_private_targets = envBool("TOKEN_GOAT_SCREENSHOT_BLOCK_PRIVATE_TARGETS", sc_cfg.block_private_targets);
+  const rm_raw = section(raw, "repomap");
+  const rm = getDefaultConfig("repomap");
+  rm.compact_file_threshold = validatedInt(rm_raw["compact_file_threshold"], rm.compact_file_threshold, ...boundsOf("repomap.compact_file_threshold"));
+  rm.exclude_tests = validatedBool(rm_raw["exclude_tests"], rm.exclude_tests);
+  rm.compact_file_threshold = envInt("TOKEN_GOAT_REPOMAP_COMPACT_THRESHOLD", rm.compact_file_threshold, ...boundsOf("repomap.compact_file_threshold"));
+  rm.exclude_tests = envBool("TOKEN_GOAT_REPOMAP_EXCLUDE_TESTS", rm.exclude_tests);
+  const og_raw = section(raw, "overflow_guard");
+  const og = getDefaultConfig("overflow_guard");
+  og.enabled = validatedBool(og_raw["enabled"], og.enabled);
+  og.max_tokens = validatedInt(og_raw["max_tokens"], og.max_tokens, ...boundsOf("overflow_guard.max_tokens"));
+  og.enabled = envBool("TOKEN_GOAT_OVERFLOW_GUARD", og.enabled);
+  og.max_tokens = envInt("TOKEN_GOAT_OVERFLOW_MAX_TOKENS", og.max_tokens, ...boundsOf("overflow_guard.max_tokens"));
+  const st_raw = section(raw, "stats");
+  const st = getDefaultConfig("stats");
+  st.record_zero_savings = validatedBool(st_raw["record_zero_savings"], st.record_zero_savings);
+  const hi_raw = section(raw, "hints");
+  const hi = getDefaultConfig("hints");
+  hi.quiet_hours = validatedStr(hi_raw["quiet_hours"], hi.quiet_hours);
+  hi.json_sidecar = validatedBool(hi_raw["json_sidecar"], hi.json_sidecar);
+  hi.min_file_lines_for_hint = validatedInt(hi_raw["min_file_lines_for_hint"], hi.min_file_lines_for_hint, ...boundsOf("hints.min_file_lines_for_hint"));
+  hi.bash_dedup_min_bytes = validatedInt(hi_raw["bash_dedup_min_bytes"], hi.bash_dedup_min_bytes, ...boundsOf("hints.bash_dedup_min_bytes"));
+  hi.bash_dedup_min_bytes = envInt("TOKEN_GOAT_BASH_DEDUP_MIN_BYTES", hi.bash_dedup_min_bytes, ...boundsOf("hints.bash_dedup_min_bytes"));
+  hi.web_dedup_min_bytes = validatedInt(hi_raw["web_dedup_min_bytes"], hi.web_dedup_min_bytes, ...boundsOf("hints.web_dedup_min_bytes"));
+  hi.web_dedup_min_bytes = envInt("TOKEN_GOAT_WEB_DEDUP_MIN_BYTES", hi.web_dedup_min_bytes, ...boundsOf("hints.web_dedup_min_bytes"));
+  hi.grep_dedup_min_matches = validatedInt(hi_raw["grep_dedup_min_matches"], hi.grep_dedup_min_matches, ...boundsOf("hints.grep_dedup_min_matches"));
+  hi.grep_dedup_min_matches = envInt("TOKEN_GOAT_GREP_DEDUP_MIN_MATCHES", hi.grep_dedup_min_matches, ...boundsOf("hints.grep_dedup_min_matches"));
+  hi.glob_dedup_min_matches = validatedInt(hi_raw["glob_dedup_min_matches"], hi.glob_dedup_min_matches, ...boundsOf("hints.glob_dedup_min_matches"));
+  hi.glob_dedup_min_matches = envInt("TOKEN_GOAT_GLOB_DEDUP_MIN_MATCHES", hi.glob_dedup_min_matches, ...boundsOf("hints.glob_dedup_min_matches"));
+  hi.write_rewrite_min_lines = validatedInt(hi_raw["write_rewrite_min_lines"], hi.write_rewrite_min_lines, ...boundsOf("hints.write_rewrite_min_lines"));
+  hi.write_rewrite_min_lines = envInt("TOKEN_GOAT_WRITE_REWRITE_MIN_LINES", hi.write_rewrite_min_lines, ...boundsOf("hints.write_rewrite_min_lines"));
+  hi.write_rewrite_unchanged_pct = validatedInt(hi_raw["write_rewrite_unchanged_pct"], hi.write_rewrite_unchanged_pct, ...boundsOf("hints.write_rewrite_unchanged_pct"));
+  hi.write_rewrite_unchanged_pct = envInt("TOKEN_GOAT_WRITE_REWRITE_UNCHANGED_PCT", hi.write_rewrite_unchanged_pct, ...boundsOf("hints.write_rewrite_unchanged_pct"));
+  hi.serve_diff_on_reread = validatedBool(hi_raw["serve_diff_on_reread"], hi.serve_diff_on_reread);
+  hi.elide_served_lines = validatedBool(hi_raw["elide_served_lines"], hi.elide_served_lines);
+  hi.subagent_markdown_first_read_deny = validatedBool(hi_raw["subagent_markdown_first_read_deny"], hi.subagent_markdown_first_read_deny);
+  hi.backoff_thresholds = validatedIntList(hi_raw["backoff_thresholds"], hi.backoff_thresholds);
+  hi.git_hint_max_ms = validatedInt(hi_raw["git_hint_max_ms"], hi.git_hint_max_ms, ...boundsOf("hints.git_hint_max_ms"));
+  hi.min_session_hint_savings_bytes = validatedInt(hi_raw["min_session_hint_savings_bytes"], hi.min_session_hint_savings_bytes, ...boundsOf("hints.min_session_hint_savings_bytes"));
+  hi.pre_skill_advisory = validatedBool(hi_raw["pre_skill_advisory"], hi.pre_skill_advisory);
+  hi.context_threshold_advisory = validatedBool(hi_raw["context_threshold_advisory"], hi.context_threshold_advisory);
+  hi.diff_hint_min_tokens_saved = validatedInt(hi_raw["diff_hint_min_tokens_saved"], hi.diff_hint_min_tokens_saved, ...boundsOf("hints.diff_hint_min_tokens_saved"));
+  hi.large_read_redirect_bytes = validatedIntWithLegacySentinel(hi_raw["large_read_redirect_bytes"], hi.large_read_redirect_bytes, 45e3, ...boundsOf("hints.large_read_redirect_bytes"));
+  hi.reread_deny = validatedBool(hi_raw["reread_deny"], hi.reread_deny);
+  hi.reread_deny_min_bytes = validatedIntWithLegacySentinel(hi_raw["reread_deny_min_bytes"], hi.reread_deny_min_bytes, 2048, ...boundsOf("hints.reread_deny_min_bytes"));
+  hi.stable_doc_compacts = validatedBool(hi_raw["stable_doc_compacts"], hi.stable_doc_compacts);
+  hi.fold_code_bodies = validatedBool(hi_raw["fold_code_bodies"], hi.fold_code_bodies);
+  hi.fold_comment_blocks = validatedBool(hi_raw["fold_comment_blocks"], hi.fold_comment_blocks);
+  hi.fold_prose_paragraphs = validatedBool(hi_raw["fold_prose_paragraphs"], hi.fold_prose_paragraphs);
+  hi.outline_large_documents = validatedBool(hi_raw["outline_large_documents"], hi.outline_large_documents);
+  hi.skeleton_large_sources = validatedBool(hi_raw["skeleton_large_sources"], hi.skeleton_large_sources);
+  hi.truncated_read_min_lines = validatedInt(hi_raw["truncated_read_min_lines"], hi.truncated_read_min_lines, ...boundsOf("hints.truncated_read_min_lines"));
+  hi.protect_recent_reads = validatedInt(hi_raw["protect_recent_reads"], hi.protect_recent_reads, ...boundsOf("hints.protect_recent_reads"));
+  hi.warn_unbalanced_shell_quoting = validatedBool(hi_raw["warn_unbalanced_shell_quoting"], hi.warn_unbalanced_shell_quoting);
+  hi.log_large_file_hint_outcomes = validatedBool(hi_raw["log_large_file_hint_outcomes"], hi.log_large_file_hint_outcomes);
+  hi.warn_unbalanced_shell_quoting = envBool("TOKEN_GOAT_WARN_UNBALANCED_SHELL_QUOTING", hi.warn_unbalanced_shell_quoting);
+  hi.serve_diff_on_reread = envBool("TOKEN_GOAT_SERVE_DIFF_ON_REREAD", hi.serve_diff_on_reread);
+  hi.elide_served_lines = envBool("TOKEN_GOAT_ELIDE_SERVED_LINES", hi.elide_served_lines);
+  hi.subagent_markdown_first_read_deny = envBool("TOKEN_GOAT_SUBAGENT_MARKDOWN_FIRST_READ_DENY", hi.subagent_markdown_first_read_deny);
+  hi.log_large_file_hint_outcomes = envBool("TOKEN_GOAT_LOG_LARGE_FILE_HINT_OUTCOMES", hi.log_large_file_hint_outcomes);
+  hi.json_sidecar = envBool("TOKEN_GOAT_HINT_JSON_SIDECAR", hi.json_sidecar);
+  hi.large_read_redirect_bytes = envInt("TOKEN_GOAT_LARGE_READ_BYTES", hi.large_read_redirect_bytes, ...boundsOf("hints.large_read_redirect_bytes"));
+  hi.cross_session_read_dedup = validatedBool(hi_raw["cross_session_read_dedup"], hi.cross_session_read_dedup);
+  hi.cross_session_read_dedup_ttl_secs = validatedInt(hi_raw["cross_session_read_dedup_ttl_secs"], hi.cross_session_read_dedup_ttl_secs, ...boundsOf("hints.cross_session_read_dedup_ttl_secs"));
+  hi.cross_session_read_dedup = envBool("TOKEN_GOAT_CROSS_SESSION_READ_DEDUP", hi.cross_session_read_dedup);
+  hi.cross_session_read_dedup_ttl_secs = envInt("TOKEN_GOAT_CROSS_SESSION_READ_DEDUP_TTL_SECS", hi.cross_session_read_dedup_ttl_secs, ...boundsOf("hints.cross_session_read_dedup_ttl_secs"));
+  hi.mcp_dedup_ttl_secs = validatedInt(hi_raw["mcp_dedup_ttl_secs"], hi.mcp_dedup_ttl_secs, ...boundsOf("hints.mcp_dedup_ttl_secs"));
+  hi.mcp_dedup_ttl_secs = envInt("TOKEN_GOAT_MCP_DEDUP_TTL_SECS", hi.mcp_dedup_ttl_secs, ...boundsOf("hints.mcp_dedup_ttl_secs"));
+  hi.session_start_reminder = validatedBool(hi_raw["session_start_reminder"], hi.session_start_reminder);
+  hi.session_start_reminder = envBool("TOKEN_GOAT_SESSION_START_REMINDER", hi.session_start_reminder);
+  hi.min_session_hint_savings_bytes = envInt("TOKEN_GOAT_SESSION_HINT_MIN_BYTES", hi.min_session_hint_savings_bytes, ...boundsOf("hints.min_session_hint_savings_bytes"));
+  hi.reread_deny = envBool("TOKEN_GOAT_REREAD_DENY", hi.reread_deny);
+  hi.reread_deny_min_bytes = envInt("TOKEN_GOAT_REREAD_DENY_MIN_BYTES", hi.reread_deny_min_bytes, ...boundsOf("hints.reread_deny_min_bytes"));
+  hi.protect_recent_reads = envInt("TOKEN_GOAT_PROTECT_RECENT_READS", hi.protect_recent_reads, ...boundsOf("hints.protect_recent_reads"));
+  hi.truncated_read_min_lines = envInt("TOKEN_GOAT_TRUNCATED_READ_MIN_LINES", hi.truncated_read_min_lines, ...boundsOf("hints.truncated_read_min_lines"));
+  hi.diff_hint_min_tokens_saved = envInt("TOKEN_GOAT_DIFF_HINT_MIN_TOKENS_SAVED", hi.diff_hint_min_tokens_saved, ...boundsOf("hints.diff_hint_min_tokens_saved"));
+  hi.min_file_lines_for_hint = envInt("TOKEN_GOAT_MIN_FILE_LINES_FOR_HINT", hi.min_file_lines_for_hint, ...boundsOf("hints.min_file_lines_for_hint"));
+  hi.git_hint_max_ms = envInt("TOKEN_GOAT_GIT_HINT_MAX_MS", hi.git_hint_max_ms, ...boundsOf("hints.git_hint_max_ms"));
+  hi.stable_doc_compacts = envBool("TOKEN_GOAT_STABLE_DOC_COMPACTS", hi.stable_doc_compacts);
+  hi.fold_code_bodies = envBool("TOKEN_GOAT_FOLD_CODE_BODIES", hi.fold_code_bodies);
+  hi.fold_comment_blocks = envBool("TOKEN_GOAT_FOLD_COMMENT_BLOCKS", hi.fold_comment_blocks);
+  hi.fold_prose_paragraphs = envBool("TOKEN_GOAT_FOLD_PROSE_PARAGRAPHS", hi.fold_prose_paragraphs);
+  hi.outline_large_documents = envBool("TOKEN_GOAT_OUTLINE_LARGE_DOCUMENTS", hi.outline_large_documents);
+  hi.skeleton_large_sources = envBool("TOKEN_GOAT_SKELETON_LARGE_SOURCES", hi.skeleton_large_sources);
+  hi.context_threshold_advisory = envBool("TOKEN_GOAT_CONTEXT_THRESHOLD_ADVISORY", hi.context_threshold_advisory);
+  hi.pre_skill_advisory = envBool("TOKEN_GOAT_PRE_SKILL_ADVISORY", hi.pre_skill_advisory);
+  hi.quiet_hours = envStr("TOKEN_GOAT_QUIET_HOURS", hi.quiet_hours);
+  const triggers_raw = hi_raw["prompt_triggers"];
+  if (Array.isArray(triggers_raw)) {
+    hi.prompt_triggers = triggers_raw.filter((t) => t !== null && typeof t === "object" && !Array.isArray(t)).map((t) => ({
+      keywords: validatedStrList(t["keywords"], []),
+      hint: validatedStr(t["hint"], "")
+    })).filter((t) => t.keywords.length > 0 && t.hint.length > 0);
+  }
+  const hk_raw = section(raw, "hooks");
+  const hk = getDefaultConfig("hooks");
+  hk.watchdog_ms = validatedInt(hk_raw["watchdog_ms"], hk.watchdog_ms, ...boundsOf("hooks.watchdog_ms"));
+  hk.watchdog_ms = envInt("TOKEN_GOAT_HOOK_WATCHDOG_MS", hk.watchdog_ms, ...boundsOf("hooks.watchdog_ms"));
+  const wf_raw = section(raw, "webfetch");
+  const wf = getDefaultConfig("webfetch");
+  wf.allow = validatedStrList(wf_raw["allow"], wf.allow);
+  wf.deny = validatedStrList(wf_raw["deny"], wf.deny);
+  wf.allow = envStrList("TOKEN_GOAT_WEBFETCH_ALLOW", wf.allow, ",");
+  wf.deny = envStrList("TOKEN_GOAT_WEBFETCH_DENY", wf.deny, ",");
+  wf.max_file_count = validatedInt(wf_raw["max_file_count"], wf.max_file_count, ...boundsOf("webfetch.max_file_count"));
+  wf.max_file_count = envInt("TOKEN_GOAT_WEB_CACHE_MAX_FILES", wf.max_file_count, ...boundsOf("webfetch.max_file_count"));
+  wf.max_bytes = validatedInt(wf_raw["max_bytes"], wf.max_bytes, ...boundsOf("webfetch.max_bytes"));
+  wf.max_bytes = envInt("TOKEN_GOAT_WEB_CACHE_MAX_BYTES", wf.max_bytes, ...boundsOf("webfetch.max_bytes"));
+  wf.compress_bodies = validatedBool(wf_raw["compress_bodies"], wf.compress_bodies);
+  wf.compress_min_bytes = validatedInt(wf_raw["compress_min_bytes"], wf.compress_min_bytes, ...boundsOf("webfetch.compress_min_bytes"));
+  wf.compress_bodies = envBool("TOKEN_GOAT_WEB_COMPRESS", wf.compress_bodies);
+  const wk_raw = section(raw, "worker");
+  const wk = getDefaultConfig("worker");
+  wk.blocked_roots = validatedStrList(wk_raw["blocked_roots"], wk.blocked_roots);
+  wk.max_pool_workers = validatedInt(wk_raw["max_pool_workers"], wk.max_pool_workers, ...boundsOf("worker.max_pool_workers"));
+  wk.max_pool_workers = envInt("TOKEN_GOAT_WORKER_MAX_POOL", wk.max_pool_workers, ...boundsOf("worker.max_pool_workers"));
+  wk.embed_threads = validatedInt(wk_raw["embed_threads"], wk.embed_threads, ...boundsOf("worker.embed_threads"));
+  wk.embed_threads = envInt("TOKEN_GOAT_EMBED_THREADS", wk.embed_threads, ...boundsOf("worker.embed_threads"));
+  wk.priority = validatedStr(wk_raw["priority"], wk.priority);
+  wk.priority = envStr("TOKEN_GOAT_WORKER_PRIORITY", wk.priority);
+  const ix_raw = section(raw, "indexing");
+  const ix = getDefaultConfig("indexing");
+  ix.large_file_symbol_only_kb = validatedInt(ix_raw["large_file_symbol_only_kb"], ix.large_file_symbol_only_kb, ...boundsOf("indexing.large_file_symbol_only_kb"));
+  ix.large_file_skip_kb = validatedInt(ix_raw["large_file_skip_kb"], ix.large_file_skip_kb, ...boundsOf("indexing.large_file_skip_kb"));
+  ix.large_file_symbol_only_kb = Math.min(ix.large_file_symbol_only_kb, ix.large_file_skip_kb);
+  ix.skip_dirs = validatedStrList(ix_raw["skip_dirs"], ix.skip_dirs);
+  ix.skip_files = validatedStrList(ix_raw["skip_files"], ix.skip_files);
+  ix.embeddings_enabled = validatedBool(ix_raw["embeddings_enabled"], ix.embeddings_enabled);
+  ix.embeddings_enabled = envBool("TOKEN_GOAT_EMBEDDINGS_ENABLED", ix.embeddings_enabled);
+  ix.cross_project_symbols = validatedBool(ix_raw["cross_project_symbols"], ix.cross_project_symbols);
+  ix.cross_project_symbols = envBool("TOKEN_GOAT_CROSS_PROJECT_SYMBOLS", ix.cross_project_symbols);
+  const cpr_raw = section(raw, "compression");
+  const cpr = getDefaultConfig("compression");
+  cpr.profile = validatedStr(cpr_raw["profile"], cpr.profile);
+  cpr.profile = envStr("TOKEN_GOAT_COMPRESS_PROFILE", cpr.profile);
+  const ctx_raw = section(raw, "context");
+  const ctx = getDefaultConfig("context");
+  ctx.model_window_tokens = validatedInt(ctx_raw["model_window_tokens"], ctx.model_window_tokens, ...boundsOf("context.model_window_tokens"));
+  ctx.model_window_tokens = envInt("TOKEN_GOAT_MODEL_WINDOW_TOKENS", ctx.model_window_tokens, ...boundsOf("context.model_window_tokens"));
+  const inj_raw = section(raw, "injection");
+  const inj = getDefaultConfig("injection");
+  inj.enabled = validatedBool(inj_raw["enabled"], inj.enabled);
+  inj.enabled = envBool("TOKEN_GOAT_INJECTION_ENABLED", inj.enabled);
+  const gd_raw = section(raw, "gdrive");
+  const gd = getDefaultConfig("gdrive");
+  gd.enabled = validatedBool(gd_raw["enabled"], gd.enabled);
+  gd.enabled = envBool("TOKEN_GOAT_GDRIVE_ENABLED", gd.enabled);
+  const red_raw = section(raw, "redaction");
+  const red = getDefaultConfig("redaction");
+  red.custom_patterns = validatedStrList(red_raw["custom_patterns"], red.custom_patterns);
+  red.custom_patterns = envStrList("TOKEN_GOAT_REDACTION_CUSTOM_PATTERNS", red.custom_patterns, "\n");
+  red.strict = validatedBool(red_raw["strict"], red.strict);
+  red.strict = envBool("TOKEN_GOAT_REDACTION_STRICT", red.strict);
+  const net_raw = section(raw, "network");
+  const net = getDefaultConfig("network");
+  net.offline = validatedBool(net_raw["offline"], net.offline);
+  net.offline = envBool("TOKEN_GOAT_OFFLINE", net.offline);
+  const mcp_raw = section(raw, "mcp");
+  const mcp = getDefaultConfig("mcp");
+  mcp.confine_reads_to_project_root = validatedBool(mcp_raw["confine_reads_to_project_root"], mcp.confine_reads_to_project_root);
+  mcp.confine_reads_to_project_root = envBool("TOKEN_GOAT_MCP_CONFINE_READS", mcp.confine_reads_to_project_root);
+  mcp.allowed_roots = validatedStrList(mcp_raw["allowed_roots"], mcp.allowed_roots);
+  mcp.allowed_roots = envStrList("TOKEN_GOAT_MCP_ALLOWED_ROOTS", mcp.allowed_roots, path2.delimiter);
+  const hs_raw = section(raw, "hint_stats");
+  const hs = getDefaultConfig("hint_stats");
+  hs.suppress_threshold_pct = validatedInt(hs_raw["suppress_threshold_pct"], hs.suppress_threshold_pct, ...boundsOf("hint_stats.suppress_threshold_pct"));
+  hs.min_sample_size = validatedInt(hs_raw["min_sample_size"], hs.min_sample_size, ...boundsOf("hint_stats.min_sample_size"));
+  const sem_raw = section(raw, "semantic");
+  const sem = getDefaultConfig("semantic");
+  sem.archive_weight = validatedFloat(sem_raw["archive_weight"], sem.archive_weight, ...boundsOf("semantic.archive_weight"));
+  sem.docs_weight = validatedFloat(sem_raw["docs_weight"], sem.docs_weight, ...boundsOf("semantic.docs_weight"));
+  return {
+    compact_assist: ca,
+    bash_compress: bc,
+    agent_report: ar,
+    bash_diff: bd,
+    bash_severity_log: sl,
+    post_read_code_compress: cc,
+    session_brief: sb,
+    skill_preservation: sp,
+    image_shrink: is_cfg,
+    screenshot: sc_cfg,
+    repomap: rm,
+    overflow_guard: og,
+    stats: st,
+    hints: hi,
+    hooks: hk,
+    webfetch: wf,
+    worker: wk,
+    indexing: ix,
+    compression: cpr,
+    context: ctx,
+    injection: inj,
+    gdrive: gd,
+    redaction: red,
+    network: net,
+    mcp,
+    hint_stats: hs,
+    semantic: sem
+  };
+}
+var CONFIG_KEY_ENV_OVERRIDES = {
+  "compact_assist.enabled": ["TOKEN_GOAT_COMPACT_ASSIST", "TOKENWISE_COMPACT_ASSIST"],
+  "bash_compress.enabled": ["TOKEN_GOAT_BASH_COMPRESS"],
+  "bash_compress.cache_min_bytes": ["TOKEN_GOAT_BASH_CACHE_MIN_BYTES"],
+  "bash_compress.cache_max_file_count": ["TOKEN_GOAT_BASH_CACHE_MAX_FILES"],
+  "bash_compress.cache_max_bytes": ["TOKEN_GOAT_BASH_CACHE_MAX_BYTES"],
+  "bash_compress.cache_max_bytes_per_output": ["TOKEN_GOAT_BASH_CACHE_MAX_BYTES_PER_OUTPUT"],
+  "bash_compress.min_net_savings_bytes": ["TOKEN_GOAT_BASH_MIN_NET_SAVINGS_BYTES"],
+  "agent_report.min_bytes": ["TOKEN_GOAT_AGENT_REPORT_MIN_BYTES"],
+  "agent_report.fence_collapse_min_lines": ["TOKEN_GOAT_AGENT_REPORT_FENCE_MIN_LINES"],
+  "agent_report.fence_collapse_keep_lines": ["TOKEN_GOAT_AGENT_REPORT_FENCE_KEEP_LINES"],
+  "session_brief.enabled": ["TOKEN_GOAT_SESSION_BRIEF"],
+  "skill_preservation.enabled": ["TOKEN_GOAT_SKILL_PRESERVATION"],
+  "skill_preservation.compress_bodies": ["TOKEN_GOAT_SKILL_COMPRESS"],
+  "skill_preservation.pre_skill_enabled": ["TOKEN_GOAT_PRE_SKILL"],
+  "skill_preservation.orphan_sweep_enabled": ["TOKEN_GOAT_ORPHAN_SWEEP"],
+  "image_shrink.max_image_pixels": ["TOKEN_GOAT_MAX_IMAGE_PIXELS"],
+  "image_shrink.ocr_enabled": ["TOKEN_GOAT_OCR_ENABLED"],
+  "image_shrink.ocr_lang": ["TOKEN_GOAT_OCR_LANG"],
+  "image_shrink.vision_tier": ["TOKEN_GOAT_VISION_TIER"],
+  "screenshot.block_private_targets": ["TOKEN_GOAT_SCREENSHOT_BLOCK_PRIVATE_TARGETS"],
+  "repomap.compact_file_threshold": ["TOKEN_GOAT_REPOMAP_COMPACT_THRESHOLD"],
+  "repomap.exclude_tests": ["TOKEN_GOAT_REPOMAP_EXCLUDE_TESTS"],
+  "overflow_guard.enabled": ["TOKEN_GOAT_OVERFLOW_GUARD"],
+  "overflow_guard.max_tokens": ["TOKEN_GOAT_OVERFLOW_MAX_TOKENS"],
+  "hints.json_sidecar": ["TOKEN_GOAT_HINT_JSON_SIDECAR"],
+  "hints.bash_dedup_min_bytes": ["TOKEN_GOAT_BASH_DEDUP_MIN_BYTES"],
+  "hints.web_dedup_min_bytes": ["TOKEN_GOAT_WEB_DEDUP_MIN_BYTES"],
+  "hints.grep_dedup_min_matches": ["TOKEN_GOAT_GREP_DEDUP_MIN_MATCHES"],
+  "hints.glob_dedup_min_matches": ["TOKEN_GOAT_GLOB_DEDUP_MIN_MATCHES"],
+  "hints.write_rewrite_min_lines": ["TOKEN_GOAT_WRITE_REWRITE_MIN_LINES"],
+  "hints.write_rewrite_unchanged_pct": ["TOKEN_GOAT_WRITE_REWRITE_UNCHANGED_PCT"],
+  "hints.large_read_redirect_bytes": ["TOKEN_GOAT_LARGE_READ_BYTES"],
+  "hints.warn_unbalanced_shell_quoting": ["TOKEN_GOAT_WARN_UNBALANCED_SHELL_QUOTING"],
+  "hints.serve_diff_on_reread": ["TOKEN_GOAT_SERVE_DIFF_ON_REREAD"],
+  "hints.elide_served_lines": ["TOKEN_GOAT_ELIDE_SERVED_LINES"],
+  "hints.subagent_markdown_first_read_deny": ["TOKEN_GOAT_SUBAGENT_MARKDOWN_FIRST_READ_DENY"],
+  "hints.log_large_file_hint_outcomes": ["TOKEN_GOAT_LOG_LARGE_FILE_HINT_OUTCOMES"],
+  "hints.cross_session_read_dedup": ["TOKEN_GOAT_CROSS_SESSION_READ_DEDUP"],
+  "hints.cross_session_read_dedup_ttl_secs": ["TOKEN_GOAT_CROSS_SESSION_READ_DEDUP_TTL_SECS"],
+  "hints.mcp_dedup_ttl_secs": ["TOKEN_GOAT_MCP_DEDUP_TTL_SECS"],
+  "hints.session_start_reminder": ["TOKEN_GOAT_SESSION_START_REMINDER"],
+  "hints.min_session_hint_savings_bytes": ["TOKEN_GOAT_SESSION_HINT_MIN_BYTES"],
+  "hints.reread_deny": ["TOKEN_GOAT_REREAD_DENY"],
+  "hints.reread_deny_min_bytes": ["TOKEN_GOAT_REREAD_DENY_MIN_BYTES"],
+  "hints.protect_recent_reads": ["TOKEN_GOAT_PROTECT_RECENT_READS"],
+  "hints.truncated_read_min_lines": ["TOKEN_GOAT_TRUNCATED_READ_MIN_LINES"],
+  "hints.diff_hint_min_tokens_saved": ["TOKEN_GOAT_DIFF_HINT_MIN_TOKENS_SAVED"],
+  "hints.min_file_lines_for_hint": ["TOKEN_GOAT_MIN_FILE_LINES_FOR_HINT"],
+  "hints.git_hint_max_ms": ["TOKEN_GOAT_GIT_HINT_MAX_MS"],
+  "hints.stable_doc_compacts": ["TOKEN_GOAT_STABLE_DOC_COMPACTS"],
+  "hints.fold_code_bodies": ["TOKEN_GOAT_FOLD_CODE_BODIES"],
+  "hints.fold_comment_blocks": ["TOKEN_GOAT_FOLD_COMMENT_BLOCKS"],
+  "hints.fold_prose_paragraphs": ["TOKEN_GOAT_FOLD_PROSE_PARAGRAPHS"],
+  "hints.outline_large_documents": ["TOKEN_GOAT_OUTLINE_LARGE_DOCUMENTS"],
+  "hints.skeleton_large_sources": ["TOKEN_GOAT_SKELETON_LARGE_SOURCES"],
+  "hints.context_threshold_advisory": ["TOKEN_GOAT_CONTEXT_THRESHOLD_ADVISORY"],
+  "hints.pre_skill_advisory": ["TOKEN_GOAT_PRE_SKILL_ADVISORY"],
+  "hints.quiet_hours": ["TOKEN_GOAT_QUIET_HOURS"],
+  "hooks.watchdog_ms": ["TOKEN_GOAT_HOOK_WATCHDOG_MS"],
+  "webfetch.max_file_count": ["TOKEN_GOAT_WEB_CACHE_MAX_FILES"],
+  "webfetch.max_bytes": ["TOKEN_GOAT_WEB_CACHE_MAX_BYTES"],
+  "webfetch.compress_bodies": ["TOKEN_GOAT_WEB_COMPRESS"],
+  "worker.max_pool_workers": ["TOKEN_GOAT_WORKER_MAX_POOL"],
+  "worker.embed_threads": ["TOKEN_GOAT_EMBED_THREADS"],
+  "worker.priority": ["TOKEN_GOAT_WORKER_PRIORITY"],
+  "compression.profile": ["TOKEN_GOAT_COMPRESS_PROFILE"],
+  "context.model_window_tokens": ["TOKEN_GOAT_MODEL_WINDOW_TOKENS"],
+  "indexing.cross_project_symbols": ["TOKEN_GOAT_CROSS_PROJECT_SYMBOLS"],
+  "injection.enabled": ["TOKEN_GOAT_INJECTION_ENABLED"],
+  "gdrive.enabled": ["TOKEN_GOAT_GDRIVE_ENABLED"],
+  "redaction.custom_patterns": ["TOKEN_GOAT_REDACTION_CUSTOM_PATTERNS"],
+  "redaction.strict": ["TOKEN_GOAT_REDACTION_STRICT"],
+  "network.offline": ["TOKEN_GOAT_OFFLINE"],
+  "mcp.confine_reads_to_project_root": ["TOKEN_GOAT_MCP_CONFINE_READS"],
+  "mcp.allowed_roots": ["TOKEN_GOAT_MCP_ALLOWED_ROOTS"],
+  "webfetch.allow": ["TOKEN_GOAT_WEBFETCH_ALLOW"],
+  "webfetch.deny": ["TOKEN_GOAT_WEBFETCH_DENY"],
+  "indexing.embeddings_enabled": ["TOKEN_GOAT_EMBEDDINGS_ENABLED"]
+};
+function saveConfig(config) {
+  const ca = config.compact_assist;
+  const bc = config.bash_compress;
+  const sp = config.skill_preservation;
+  const is_cfg = config.image_shrink;
+  const wasExplicit = isAutoTriggerMultiplierExplicit();
+  const defaultMultiplier = getDefaultConfig("compact_assist").auto_trigger_multiplier;
+  const keepsMultiplierDefault = !wasExplicit && ca.auto_trigger_multiplier === defaultMultiplier;
+  const data = {
+    compact_assist: {
+      enabled: ca.enabled,
+      triggers: ca.triggers,
+      min_events: ca.min_events,
+      max_manifest_tokens: ca.max_manifest_tokens,
+      ...keepsMultiplierDefault ? {} : { auto_trigger_multiplier: ca.auto_trigger_multiplier },
+      compact_skip_ttl_secs: ca.compact_skip_ttl_secs,
+      noise_floor_tokens: ca.noise_floor_tokens,
+      edited_dir_group_threshold: ca.edited_dir_group_threshold,
+      max_section_lines: ca.max_section_lines,
+      wide_session_threshold: ca.wide_session_threshold,
+      orchestrator_commit_threshold: ca.orchestrator_commit_threshold,
+      max_manifest_chars: ca.max_manifest_chars,
+      summary_budget_chars: ca.summary_budget_chars,
+      harness: ca.harness
+    },
+    bash_compress: {
+      enabled: bc.enabled,
+      disabled_filters: bc.disabled_filters,
+      max_lines: bc.max_lines,
+      max_bytes: bc.max_bytes,
+      timeout_seconds: bc.timeout_seconds,
+      cache_min_bytes: bc.cache_min_bytes,
+      cache_max_file_count: bc.cache_max_file_count,
+      cache_max_bytes: bc.cache_max_bytes,
+      cache_max_bytes_per_output: bc.cache_max_bytes_per_output,
+      min_net_savings_bytes: bc.min_net_savings_bytes,
+      elide_served_shell_output: bc.elide_served_shell_output
+    },
+    agent_report: {
+      min_bytes: config.agent_report.min_bytes,
+      fence_collapse_min_lines: config.agent_report.fence_collapse_min_lines,
+      fence_collapse_keep_lines: config.agent_report.fence_collapse_keep_lines
+    },
+    bash_diff: {
+      max_hunks_per_file: config.bash_diff.max_hunks_per_file
+    },
+    bash_severity_log: {
+      context_lines: config.bash_severity_log.context_lines,
+      score_threshold: config.bash_severity_log.score_threshold
+    },
+    post_read_code_compress: {
+      min_lines: config.post_read_code_compress.min_lines
+    },
+    session_brief: {
+      enabled: config.session_brief.enabled
+    },
+    skill_preservation: {
+      enabled: sp.enabled,
+      max_cache_bytes: sp.max_cache_bytes,
+      orphan_sweep_enabled: sp.orphan_sweep_enabled,
+      orphan_age_secs: sp.orphan_age_secs,
+      truncation_budget_tokens: sp.truncation_budget_tokens,
+      compress_bodies: sp.compress_bodies,
+      compress_min_bytes: sp.compress_min_bytes,
+      inline_snippets: sp.inline_snippets,
+      pre_skill_enabled: sp.pre_skill_enabled,
+      first_load_compact: sp.first_load_compact,
+      post_compact_full_loads: sp.post_compact_full_loads
+    },
+    image_shrink: {
+      enabled: is_cfg.enabled,
+      jpeg_quality: is_cfg.jpeg_quality,
+      max_image_pixels: is_cfg.max_image_pixels,
+      screenshot_redirect: is_cfg.screenshot_redirect,
+      ocr_enabled: is_cfg.ocr_enabled,
+      ocr_min_confidence: is_cfg.ocr_min_confidence,
+      ocr_lang: is_cfg.ocr_lang,
+      vision_tier: is_cfg.vision_tier
+    },
+    screenshot: {
+      chrome_path: config.screenshot.chrome_path,
+      block_private_targets: config.screenshot.block_private_targets
+    },
+    repomap: {
+      compact_file_threshold: config.repomap.compact_file_threshold,
+      exclude_tests: config.repomap.exclude_tests
+    },
+    overflow_guard: {
+      enabled: config.overflow_guard.enabled,
+      max_tokens: config.overflow_guard.max_tokens
+    },
+    stats: {
+      record_zero_savings: config.stats.record_zero_savings
+    },
+    hints: {
+      quiet_hours: config.hints.quiet_hours,
+      json_sidecar: config.hints.json_sidecar,
+      min_file_lines_for_hint: config.hints.min_file_lines_for_hint,
+      bash_dedup_min_bytes: config.hints.bash_dedup_min_bytes,
+      web_dedup_min_bytes: config.hints.web_dedup_min_bytes,
+      grep_dedup_min_matches: config.hints.grep_dedup_min_matches,
+      glob_dedup_min_matches: config.hints.glob_dedup_min_matches,
+      write_rewrite_min_lines: config.hints.write_rewrite_min_lines,
+      write_rewrite_unchanged_pct: config.hints.write_rewrite_unchanged_pct,
+      serve_diff_on_reread: config.hints.serve_diff_on_reread,
+      elide_served_lines: config.hints.elide_served_lines,
+      subagent_markdown_first_read_deny: config.hints.subagent_markdown_first_read_deny,
+      backoff_thresholds: config.hints.backoff_thresholds,
+      git_hint_max_ms: config.hints.git_hint_max_ms,
+      min_session_hint_savings_bytes: config.hints.min_session_hint_savings_bytes,
+      pre_skill_advisory: config.hints.pre_skill_advisory,
+      context_threshold_advisory: config.hints.context_threshold_advisory,
+      diff_hint_min_tokens_saved: config.hints.diff_hint_min_tokens_saved,
+      large_read_redirect_bytes: config.hints.large_read_redirect_bytes,
+      reread_deny: config.hints.reread_deny,
+      reread_deny_min_bytes: config.hints.reread_deny_min_bytes,
+      stable_doc_compacts: config.hints.stable_doc_compacts,
+      fold_code_bodies: config.hints.fold_code_bodies,
+      fold_comment_blocks: config.hints.fold_comment_blocks,
+      fold_prose_paragraphs: config.hints.fold_prose_paragraphs,
+      outline_large_documents: config.hints.outline_large_documents,
+      skeleton_large_sources: config.hints.skeleton_large_sources,
+      truncated_read_min_lines: config.hints.truncated_read_min_lines,
+      protect_recent_reads: config.hints.protect_recent_reads,
+      prompt_triggers: config.hints.prompt_triggers,
+      warn_unbalanced_shell_quoting: config.hints.warn_unbalanced_shell_quoting,
+      log_large_file_hint_outcomes: config.hints.log_large_file_hint_outcomes,
+      cross_session_read_dedup: config.hints.cross_session_read_dedup,
+      cross_session_read_dedup_ttl_secs: config.hints.cross_session_read_dedup_ttl_secs,
+      mcp_dedup_ttl_secs: config.hints.mcp_dedup_ttl_secs,
+      session_start_reminder: config.hints.session_start_reminder
+    },
+    hooks: {
+      watchdog_ms: config.hooks.watchdog_ms
+    },
+    webfetch: {
+      allow: config.webfetch.allow,
+      deny: config.webfetch.deny,
+      max_file_count: config.webfetch.max_file_count,
+      max_bytes: config.webfetch.max_bytes,
+      compress_bodies: config.webfetch.compress_bodies,
+      compress_min_bytes: config.webfetch.compress_min_bytes
+    },
+    worker: {
+      blocked_roots: config.worker.blocked_roots,
+      max_pool_workers: config.worker.max_pool_workers,
+      embed_threads: config.worker.embed_threads,
+      priority: config.worker.priority
+    },
+    indexing: {
+      large_file_symbol_only_kb: config.indexing.large_file_symbol_only_kb,
+      large_file_skip_kb: config.indexing.large_file_skip_kb,
+      skip_dirs: config.indexing.skip_dirs,
+      skip_files: config.indexing.skip_files,
+      embeddings_enabled: config.indexing.embeddings_enabled,
+      cross_project_symbols: config.indexing.cross_project_symbols
+    },
+    compression: {
+      profile: config.compression.profile
+    },
+    context: {
+      model_window_tokens: config.context.model_window_tokens
+    },
+    injection: {
+      enabled: config.injection.enabled
+    },
+    gdrive: {
+      enabled: config.gdrive.enabled
+    },
+    redaction: {
+      custom_patterns: config.redaction.custom_patterns,
+      strict: config.redaction.strict
+    },
+    network: {
+      offline: config.network.offline
+    },
+    mcp: {
+      confine_reads_to_project_root: config.mcp.confine_reads_to_project_root
+    },
+    hint_stats: {
+      suppress_threshold_pct: config.hint_stats.suppress_threshold_pct,
+      min_sample_size: config.hint_stats.min_sample_size
+    },
+    semantic: {
+      archive_weight: config.semantic.archive_weight,
+      docs_weight: config.semantic.docs_weight
+    }
+  };
+  const toml = stringify(data);
+  atomicWriteText(configPath(), toml);
+  _cached2 = null;
+}
+
+export {
+  parse,
+  stringify,
+  detectHarness,
+  getHarnessName,
+  envBool,
+  envInt,
+  envStrList,
+  fingerprintContent,
+  shortFingerprint,
+  fingerprintFile,
+  fileIsAbsent,
+  DEFAULT_OCR_LANG,
+  SUPPORTED_OCR_LANG_CODES,
+  isSupportedOcrLang,
+  resolveOcrLangs,
+  defaultConfig,
+  makeProjectAt,
+  findProject,
+  getDisplayRoot,
+  isUnderSystemTemp,
+  resolveProjectRoot,
+  PROJECT_LOCKED_SECTIONS,
+  PROJECT_LOCKED_KEYS,
+  lastProjectConfigLockedKeys,
+  readConfigSource,
+  getProjectConfigInfo,
+  isAutoTriggerMultiplierExplicit,
+  validateNumericField,
+  validateEnumField,
+  getLastConfigParseError,
+  getLastProjectConfigParseError,
+  resolveConfigKeyLayer,
+  loadConfig,
+  invalidateConfigCache,
+  loadPersistedConfig,
+  CONFIG_KEY_ENV_OVERRIDES,
+  saveConfig
+};
+/*! Bundled license information:
+
+smol-toml/dist/date.js:
+smol-toml/dist/error.js:
+smol-toml/dist/util.js:
+smol-toml/dist/primitive.js:
+smol-toml/dist/extract.js:
+smol-toml/dist/struct.js:
+smol-toml/dist/parse.js:
+smol-toml/dist/stringify.js:
+smol-toml/dist/index.js:
+  (*!
+   * Copyright (c) Squirrel Chat et al., All rights reserved.
+   * SPDX-License-Identifier: BSD-3-Clause
+   *
+   * Redistribution and use in source and binary forms, with or without
+   * modification, are permitted provided that the following conditions are met:
+   *
+   * 1. Redistributions of source code must retain the above copyright notice, this
+   *    list of conditions and the following disclaimer.
+   * 2. Redistributions in binary form must reproduce the above copyright notice,
+   *    this list of conditions and the following disclaimer in the
+   *    documentation and/or other materials provided with the distribution.
+   * 3. Neither the name of the copyright holder nor the names of its contributors
+   *    may be used to endorse or promote products derived from this software without
+   *    specific prior written permission.
+   *
+   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+   * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+   * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+   *)
+*/