token-goat 2.9.29 → 2.9.31

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

@@ -0,0 +1,122 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/image_isobmff.ts
+init_define_import_meta_env();
+var AVIF_BRANDS = /* @__PURE__ */ new Set(["avif", "avis"]);
+var HEIC_BRANDS = /* @__PURE__ */ new Set(["heic", "heix", "hevc", "heim", "heis", "hevm", "hevs"]);
+var HEIF_GENERIC_BRANDS = /* @__PURE__ */ new Set(["mif1", "msf1"]);
+var FULLBOX_PREFIX = 4;
+function readBoxes(buf, start, end) {
+  const boxes = [];
+  const limit = Math.min(end, buf.length);
+  let pos = start;
+  while (pos + 8 <= limit) {
+    let size = buf.readUInt32BE(pos);
+    const type = buf.toString("latin1", pos + 4, pos + 8);
+    let header = 8;
+    if (size === 1) {
+      if (pos + 16 > limit) break;
+      const large = buf.readBigUInt64BE(pos + 8);
+      if (large > BigInt(limit - pos)) break;
+      size = Number(large);
+      header = 16;
+    } else if (size === 0) {
+      size = limit - pos;
+    }
+    if (size < header || pos + size > limit) break;
+    boxes.push({ type, body: pos + header, end: pos + size });
+    pos += size;
+  }
+  return boxes;
+}
+function findBox(boxes, type) {
+  return boxes.find((b) => b.type === type);
+}
+function classifyBrands(buf, ftyp) {
+  if (ftyp.end - ftyp.body < 8) return null;
+  const brands = [buf.toString("latin1", ftyp.body, ftyp.body + 4)];
+  for (let p = ftyp.body + 8; p + 4 <= ftyp.end; p += 4) brands.push(buf.toString("latin1", p, p + 4));
+  if (brands.some((b) => AVIF_BRANDS.has(b))) return "avif";
+  if (brands.some((b) => HEIC_BRANDS.has(b))) return "heic";
+  if (brands.some((b) => HEIF_GENERIC_BRANDS.has(b))) return "heif";
+  return null;
+}
+function primaryItemId(buf, children) {
+  const pitm = findBox(children, "pitm");
+  if (pitm === void 0 || pitm.end - pitm.body < FULLBOX_PREFIX + 2) return null;
+  const version = buf[pitm.body];
+  if (version === 0) return buf.readUInt16BE(pitm.body + FULLBOX_PREFIX);
+  if (pitm.end - pitm.body < FULLBOX_PREFIX + 4) return null;
+  return buf.readUInt32BE(pitm.body + FULLBOX_PREFIX);
+}
+function itemProperties(buf, ipma, itemId) {
+  if (ipma.end - ipma.body < FULLBOX_PREFIX + 4) return null;
+  const version = buf[ipma.body];
+  const wide = (buf.readUIntBE(ipma.body + 1, 3) & 1) === 1;
+  const entryCount = buf.readUInt32BE(ipma.body + FULLBOX_PREFIX);
+  let pos = ipma.body + FULLBOX_PREFIX + 4;
+  const idBytes = version < 1 ? 2 : 4;
+  const assocBytes = wide ? 2 : 1;
+  for (let e = 0; e < entryCount; e++) {
+    if (pos + idBytes + 1 > ipma.end) return null;
+    const id = idBytes === 2 ? buf.readUInt16BE(pos) : buf.readUInt32BE(pos);
+    const count = buf[pos + idBytes];
+    pos += idBytes + 1;
+    if (pos + count * assocBytes > ipma.end) return null;
+    if (id === itemId) {
+      const out = [];
+      for (let a = 0; a < count; a++) {
+        const at = pos + a * assocBytes;
+        out.push(wide ? buf.readUInt16BE(at) & 32767 : buf[at] & 127);
+      }
+      return out;
+    }
+    pos += count * assocBytes;
+  }
+  return null;
+}
+function probeIsoBmffMeta(buf) {
+  if (buf.length < 16 || buf.toString("latin1", 4, 8) !== "ftyp") return null;
+  const top = readBoxes(buf, 0, buf.length);
+  const ftyp = top[0];
+  if (ftyp === void 0 || ftyp.type !== "ftyp") return null;
+  const format = classifyBrands(buf, ftyp);
+  if (format === null) return null;
+  const meta = findBox(top, "meta");
+  if (meta === void 0 || meta.end - meta.body < FULLBOX_PREFIX) return null;
+  const metaChildren = readBoxes(buf, meta.body + FULLBOX_PREFIX, meta.end);
+  const iprp = findBox(metaChildren, "iprp");
+  if (iprp === void 0) return null;
+  const iprpChildren = readBoxes(buf, iprp.body, iprp.end);
+  const ipco = findBox(iprpChildren, "ipco");
+  if (ipco === void 0) return null;
+  const props = readBoxes(buf, ipco.body, ipco.end);
+  const ipma = findBox(iprpChildren, "ipma");
+  const itemId = primaryItemId(buf, metaChildren);
+  const wanted = ipma !== void 0 && itemId !== null ? itemProperties(buf, ipma, itemId) : null;
+  const candidates = wanted === null ? props : wanted.map((index) => props[index - 1]).filter((b) => b !== void 0);
+  let width = 0;
+  let height = 0;
+  let rotated = false;
+  for (const prop of candidates) {
+    if (prop.type === "ispe" && prop.end - prop.body >= FULLBOX_PREFIX + 8) {
+      const w = buf.readUInt32BE(prop.body + FULLBOX_PREFIX);
+      const h = buf.readUInt32BE(prop.body + FULLBOX_PREFIX + 4);
+      if (wanted !== null || w * h > width * height) {
+        width = w;
+        height = h;
+      }
+    } else if (prop.type === "irot" && prop.end - prop.body >= 1 && wanted !== null) {
+      rotated = (buf[prop.body] & 3) % 2 === 1;
+    }
+  }
+  if (width <= 0 || height <= 0) return null;
+  return rotated ? { width: height, height: width, format } : { width, height, format };
+}
+export {
+  probeIsoBmffMeta
+};

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

@@ -0,0 +1,52 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  CODEX_GATE_BEGIN,
+  CODEX_GATE_END,
+  INSTRUCTION_GATE_BEGIN,
+  INSTRUCTION_GATE_END,
+  checkHarnessCacheEfficiency,
+  checkInstructionGates,
+  findActiveGlobalGates,
+  findInstructionGateCandidates,
+  repairInstructionGates
+} from "./token-goat-chunk-IA6XSPE3.mjs";
+import "./token-goat-chunk-7MAOA6X4.mjs";
+import "./token-goat-chunk-CXHOFN7R.mjs";
+import "./token-goat-chunk-QQTWJY2O.mjs";
+import "./token-goat-chunk-G5PJ7AGM.mjs";
+import "./token-goat-chunk-BPGCUMR7.mjs";
+import "./token-goat-chunk-C75NA7PL.mjs";
+import "./token-goat-chunk-CBIQ7WTD.mjs";
+import "./token-goat-chunk-76FGDLRO.mjs";
+import "./token-goat-chunk-U4WHMG6Y.mjs";
+import "./token-goat-chunk-GVB2MUST.mjs";
+import "./token-goat-chunk-XB5KKOCG.mjs";
+import "./token-goat-chunk-OUKDTVNU.mjs";
+import "./token-goat-chunk-BFCWY73P.mjs";
+import "./token-goat-chunk-KGEFFSHD.mjs";
+import "./token-goat-chunk-XX6O25RN.mjs";
+import "./token-goat-chunk-HAVAOB3S.mjs";
+import "./token-goat-chunk-T5P5ACNQ.mjs";
+import "./token-goat-chunk-7EZTZOMC.mjs";
+import "./token-goat-chunk-QYHO5CPH.mjs";
+import "./token-goat-chunk-4GBVPH3D.mjs";
+import "./token-goat-chunk-YZAAZU2S.mjs";
+import "./token-goat-chunk-IVE6U7KV.mjs";
+import "./token-goat-chunk-HU4TORC5.mjs";
+import "./token-goat-chunk-GGGG7RWB.mjs";
+import "./token-goat-chunk-AM5V6GSX.mjs";
+import "./token-goat-chunk-FNFBKLRD.mjs";
+import "./token-goat-chunk-CO3UYX6G.mjs";
+import "./token-goat-chunk-A37V4PBF.mjs";
+export {
+  CODEX_GATE_BEGIN,
+  CODEX_GATE_END,
+  INSTRUCTION_GATE_BEGIN,
+  INSTRUCTION_GATE_END,
+  checkHarnessCacheEfficiency,
+  checkInstructionGates,
+  findActiveGlobalGates,
+  findInstructionGateCandidates,
+  repairInstructionGates
+};

package/dist/{token-goat-chunk-RQGGMPCR.mjs → token-goat-chunk-UOUDVA5U.mjs}

@@ -18,7 +18,7 @@ import {
   readServerKey,
   touchMarker,
   writeFrame
-} from "./token-goat-chunk-DPNLUJWB.mjs";
+} from "./token-goat-chunk-N5MMR2IW.mjs";
 import {
   envBool
 } from "./token-goat-chunk-IVE6U7KV.mjs";
@@ -31,13 +31,15 @@ init_define_import_meta_env();
 import { spawn } from "node:child_process";
 import * as fs from "node:fs";
 import * as net from "node:net";
+import * as os from "node:os";
 var HANDSHAKE_TIMEOUT_MS = 150;
 var FIND_BUDGET_MS = 300;
+var HEDGE_MS = 40;
 var RESPONSE_TIMEOUT_MS = 12e4;
 var CONTROL_WAIT_MS = 1e4;
 var SPAWN_RETRY_MS = 3e4;
 var DISABLED_MARKER_TTL_MS = 10 * 6e4;
-function attempt(slot, key, request, handshakeMs, dir) {
+function attempt(slot, key, request, handshakeMs, dir, race) {
   return new Promise((resolve) => {
     const socket = net.connect(endpointFor(slot, dir));
     const nc = nonce();
@@ -51,6 +53,10 @@ function attempt(slot, key, request, handshakeMs, dir) {
       resolve(outcome);
     };
     let timer = setTimeout(() => finish({ kind: "busy" }), handshakeMs);
+    const cancel = () => {
+      if (!dispatched) finish({ kind: "busy" });
+    };
+    race?.onCancel(cancel);
     socket.on("error", (e) => {
       if (dispatched) finish({ kind: "lost" });
       else finish({ kind: e.code === "ENOENT" || e.code === "ECONNREFUSED" ? "absent" : "refused" });
@@ -70,9 +76,10 @@ function attempt(slot, key, request, handshakeMs, dir) {
           const body = JSON.stringify(request);
           const frame = encodeFrame({ t: "req", mac: mac(key, "C", nc, ns, body), body });
           if (!frameFits(frame)) return finish({ kind: "oversize" });
+          if (race !== void 0 && !race.claim(cancel)) return finish({ kind: "busy" });
           dispatched = true;
           clearTimeout(timer);
-          timer = setTimeout(() => finish({ kind: "lost" }), RESPONSE_TIMEOUT_MS);
+          if (request.kind !== "cli") timer = setTimeout(() => finish({ kind: "lost" }), RESPONSE_TIMEOUT_MS);
           socket.write(frame);
           return;
         }
@@ -97,7 +104,9 @@ function startServer(slot) {
   if (disabled || markerAgeMs(`spawn-${slot}`) < SPAWN_RETRY_MS || !fs.existsSync(launcher)) return;
   touchMarker(`spawn-${slot}`);
   try {
-    spawn(process.execPath, [launcher, "hook-server", "run", "--slot", String(slot)], { detached: true, stdio: "ignore", windowsHide: true }).unref();
+    const child = spawn(process.execPath, [launcher, "hook-server", "run", "--slot", String(slot)], { cwd: os.tmpdir(), detached: true, stdio: "ignore", windowsHide: true });
+    child.on("error", () => void 0);
+    child.unref();
   } catch {
   }
 }
@@ -113,17 +122,56 @@ async function callServer(request, opts = {}) {
     return void 0;
   }
   const deadline = Date.now() + FIND_BUDGET_MS;
-  for (let slot = 0; slot < SERVER_SLOTS && Date.now() < deadline; slot++) {
-    const outcome = await attempt(slot, key, request, opts.handshakeMs ?? HANDSHAKE_TIMEOUT_MS);
-    if (outcome.kind === "served") return outcome.reply;
-    if (outcome.kind === "lost") return "lost";
-    if (outcome.kind === "absent") {
-      if (autostart) startServer(slot);
-      return void 0;
-    }
-    if (outcome.kind === "stale" || outcome.kind === "oversize") return void 0;
-  }
-  return void 0;
+  const handshakeMs = opts.handshakeMs ?? HANDSHAKE_TIMEOUT_MS;
+  return new Promise((resolve) => {
+    let claimed = false;
+    let settled = false;
+    let exhausted = false;
+    let next = 0;
+    let pending = 0;
+    let hedge;
+    const cancels = [];
+    const settle = (value) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(hedge);
+      for (const cancel of cancels) cancel();
+      resolve(value);
+    };
+    const race = {
+      claim: (self) => {
+        if (claimed || settled) return false;
+        claimed = true;
+        clearTimeout(hedge);
+        for (const cancel of cancels) if (cancel !== self) cancel();
+        return true;
+      },
+      onCancel: (cancel) => cancels.push(cancel)
+    };
+    const askNext = () => {
+      clearTimeout(hedge);
+      if (settled || claimed || exhausted || next >= SERVER_SLOTS || Date.now() >= deadline) {
+        if (pending === 0 && !claimed) settle(void 0);
+        return;
+      }
+      const slot = next++;
+      pending++;
+      void attempt(slot, key, request, handshakeMs, void 0, race).then((outcome) => {
+        pending--;
+        if (outcome.kind === "served") return settle(outcome.reply);
+        if (outcome.kind === "lost") return settle("lost");
+        if (claimed) return;
+        if (outcome.kind === "stale" || outcome.kind === "oversize") return settle(void 0);
+        if (outcome.kind === "absent") {
+          if (autostart) startServer(slot);
+          exhausted = true;
+        }
+        askNext();
+      });
+      if (next < SERVER_SLOTS) hedge = setTimeout(askNext, HEDGE_MS);
+    };
+    askNext();
+  });
 }
 async function relayViaServer(event, input, harnessWaitMs) {
   try {
@@ -147,17 +195,29 @@ async function relayViaServer(event, input, harnessWaitMs) {
 var WARM_CLI_COMMANDS = /* @__PURE__ */ new Set([
   "answer",
   "brief",
+  "call-chain",
+  "callers",
   "changed",
+  "context-for",
+  "dead",
+  "deps",
   "exports",
+  "find",
+  "impact",
   "imports",
+  "locate",
   "map",
   "outline",
   "read",
   "refs",
+  "scope",
   "section",
   "semantic",
+  "similar",
   "skeleton",
-  "symbol"
+  "symbol",
+  "test-for",
+  "types"
 ]);
 function warmCliEligible(argv) {
   const command = argv[2];

package/dist/{token-goat-chunk-HNFZZHFW.mjs → token-goat-chunk-URRJ33GR.mjs}

@@ -1,5 +1,11 @@
 import { createRequire as __cjsRequire } from 'node:module';
 const require = __cjsRequire(import.meta.url);
+import {
+  redactSecrets
+} from "./token-goat-chunk-T5P5ACNQ.mjs";
+import {
+  loadConfig
+} from "./token-goat-chunk-7EZTZOMC.mjs";
 import {
   NotAnOfficeDocumentError,
   assertOoxmlWithinDeadline,
@@ -12,10 +18,13 @@ import {
   parseOoxmlPart,
   readOoxmlZip,
   sortNumberedParts
-} from "./token-goat-chunk-UXSXQQIY.mjs";
+} from "./token-goat-chunk-2M7E4PF7.mjs";
+import {
+  findOpenTags
+} from "./token-goat-chunk-E45INMY3.mjs";
 import {
   compileGuardedRegex
-} from "./token-goat-chunk-JTKCQMQA.mjs";
+} from "./token-goat-chunk-HU4TORC5.mjs";
 import {
   init_define_import_meta_env
 } from "./token-goat-chunk-A37V4PBF.mjs";
@@ -109,7 +118,14 @@ async function notesPathFor(entries, slidePath, budget) {
   return null;
 }
 function inlineSlideMath(xml) {
-  return inlineMathRuns(xml, '<a:r><a:t xml:space="preserve">', "</a:t></a:r>").replace(/<a14:m(?:\s[^>]*)?>/g, "").replace(/<\/a14:m>/g, "");
+  const withRuns = inlineMathRuns(xml, '<a:r><a:t xml:space="preserve">', "</a:t></a:r>");
+  let bare = "";
+  let pos = 0;
+  for (const tag of findOpenTags(withRuns, /<a14:m(?=[\s>])/g)) {
+    bare += withRuns.slice(pos, tag.start);
+    pos = tag.end;
+  }
+  return (bare + withRuns.slice(pos)).replace(/<\/a14:m>/g, "");
 }
 async function parseSlide(entries, path, budget) {
   const xml = decodeZipEntry(entries, path, budget);
@@ -194,10 +210,11 @@ async function pptxTextGrep(filePath, pattern, deadline = ooxmlWorkDeadline()) {
   if (!guarded.ok) throw new Error(`invalid --grep pattern: ${pattern} -- the pattern ${guarded.reason}`);
   const re = guarded.re;
   const out = [];
+  const config = loadConfig();
   for (let i = 0; i < slidePaths.length; i++) {
     assertOoxmlWithinDeadline(deadline, "Narrow the read to specific slides with pptx-slide, or use a smaller deck.");
     const parsed = await parseSlide(entries, slidePaths[i], budget);
-    const text = flatSlideText(parsed);
+    const text = redactSecrets(flatSlideText(parsed), config).text;
     if (re.test(text)) {
       const idx = text.search(re);
       const snippet = text.slice(Math.max(0, idx - 40), idx + 80).trim();
@@ -208,6 +225,7 @@ async function pptxTextGrep(filePath, pattern, deadline = ooxmlWorkDeadline()) {
 }
 
 export {
+  inlineSlideMath,
   pptxOutline,
   pptxSlideText,
   pptxAllSlidesText,

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

@@ -0,0 +1,165 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  isIndexedRoot,
+  recordIndexedRoot
+} from "./token-goat-chunk-M3LFJDPU.mjs";
+import {
+  MAX_FILES_SCANNED,
+  walkProject
+} from "./token-goat-chunk-ZNMNUPAZ.mjs";
+import {
+  reconcileProject
+} from "./token-goat-chunk-PFWIMH2E.mjs";
+import {
+  getTrackedFiles
+} from "./token-goat-chunk-OBOFIHKN.mjs";
+import {
+  isDotenvPath
+} from "./token-goat-chunk-GVB2MUST.mjs";
+import {
+  loadConfig
+} from "./token-goat-chunk-7EZTZOMC.mjs";
+import {
+  findProject,
+  isUnderSystemTemp
+} from "./token-goat-chunk-4GBVPH3D.mjs";
+import {
+  envBool
+} from "./token-goat-chunk-IVE6U7KV.mjs";
+import {
+  countNoun,
+  extractErrorMessage,
+  isUnderBlockedRoot,
+  runGit
+} from "./token-goat-chunk-HU4TORC5.mjs";
+import {
+  echoedValue
+} from "./token-goat-chunk-GGGG7RWB.mjs";
+import {
+  canonicalize,
+  foldPath
+} from "./token-goat-chunk-AM5V6GSX.mjs";
+import {
+  normalizePath
+} from "./token-goat-chunk-FNFBKLRD.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/install_index.ts
+init_define_import_meta_env();
+import * as fs2 from "node:fs";
+
+// src/walk_index.ts
+init_define_import_meta_env();
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+function isWalkExcluded(file) {
+  if (isDotenvPath(file)) return true;
+  const base = path.basename(file).toLowerCase();
+  if (base.endsWith(".d.ts")) return true;
+  return false;
+}
+function assertWalkableRoot(root) {
+  let resolved = path.resolve(root);
+  try {
+    resolved = fs.realpathSync.native(resolved);
+  } catch {
+  }
+  const norm = foldPath(normalizePath(resolved));
+  const fsRoot = foldPath(normalizePath(path.parse(resolved).root));
+  if (norm === fsRoot) {
+    throw new Error(`refusing to walk-index a filesystem root: ${resolved}`);
+  }
+  const home = os.homedir();
+  if (home) {
+    const normHome = foldPath(normalizePath(path.resolve(home)));
+    if (norm === normHome) {
+      throw new Error(`refusing to walk-index the home directory: ${resolved}`);
+    }
+    const boundary = norm.endsWith("/") ? norm : `${norm}/`;
+    if (normHome.startsWith(boundary)) {
+      throw new Error(`refusing to walk-index ${echoedValue(resolved)} \u2014 it contains the home directory`);
+    }
+  }
+}
+var MAX_FILES_SCANNED_FORCED = 5e5;
+function collectWalkIndexFiles(root, opts = {}) {
+  const resolved = path.resolve(root);
+  assertWalkableRoot(resolved);
+  const force = opts.force === true;
+  const ceiling = force ? MAX_FILES_SCANNED_FORCED : MAX_FILES_SCANNED;
+  const { files } = walkProject(resolved, { includeEmbeddableDocuments: true, maxFiles: ceiling });
+  if (files.length >= ceiling) {
+    throw new Error(
+      `${echoedValue(resolved)} has too many source files (walk stopped at ${ceiling}; the real total is at least that). ` + (force ? "Even --force-walk will not walk a tree this large \u2014 point at a narrower path." : `Index a git repo, point at a narrower path, or pass --force-walk to raise the cap to ${MAX_FILES_SCANNED_FORCED}.`)
+    );
+  }
+  return files.filter((f) => !isWalkExcluded(f));
+}
+
+// src/install_index.ts
+var INSTALL_INDEX_BUDGET_MS = 1e4;
+var INSTALL_INDEX_ENV = "TOKEN_GOAT_INSTALL_INDEX";
+function isOwnGitToplevel(root) {
+  const toplevel = runGit(["rev-parse", "--show-toplevel"], { cwd: root });
+  if (toplevel.exitCode !== 0 || toplevel.stdout.trim() === "") return false;
+  return foldPath(canonicalize(fs2.realpathSync(toplevel.stdout.trim()))) === foldPath(canonicalize(fs2.realpathSync(root)));
+}
+function queueInstallIndex(cwd, opts = {}) {
+  try {
+    if (opts.enabled === false || !envBool(INSTALL_INDEX_ENV, true)) return { status: "skipped", reason: "disabled" };
+    const project = findProject(cwd);
+    if (project === null) return { status: "skipped", reason: "no-project" };
+    const root = project.root;
+    try {
+      assertWalkableRoot(root);
+    } catch {
+      return { status: "skipped", reason: "broad-root", root };
+    }
+    if (isUnderSystemTemp(root)) return { status: "skipped", reason: "temp", root };
+    if (isUnderBlockedRoot(root, loadConfig().worker.blocked_roots)) return { status: "skipped", reason: "blocked", root };
+    if (isIndexedRoot(root)) return { status: "skipped", reason: "indexed", root };
+    if (getTrackedFiles(root).length === 0) return { status: "skipped", reason: isOwnGitToplevel(root) ? "untracked" : "not-git", root };
+    const result = reconcileProject({ cwd: root, budgetMs: INSTALL_INDEX_BUDGET_MS });
+    recordIndexedRoot(root);
+    if (result.enqueued === 0) return { status: "skipped", reason: "nothing-queued", root };
+    return { status: "queued", root, files: result.enqueued };
+  } catch (e) {
+    return { status: "failed", error: extractErrorMessage(e) };
+  }
+}
+function formatInstallIndexResult(result) {
+  if (result.status === "queued") {
+    return `Indexing ${result.root} in the background (${countNoun(result.files, "file")} queued); \`token-goat doctor\` shows progress.`;
+  }
+  if (result.status === "failed") {
+    return `Could not queue this project for indexing (${result.error}); run \`token-goat index\` inside it instead.`;
+  }
+  switch (result.reason) {
+    case "no-project":
+      return "No project here to index. Run `token-goat index` inside a project, or start a session in one after it has been indexed.";
+    case "broad-root":
+      return `${result.root ?? "This folder"} is too broad to index automatically (a home or drive root); run \`token-goat index\` inside a specific project.`;
+    case "temp":
+      return `${result.root ?? "This folder"} is under the system temp directory, so install does not index it automatically; run \`token-goat index\` there to index it.`;
+    case "not-git":
+      return `${result.root ?? "This folder"} is not a git repository, so it was not indexed. Run \`token-goat index --walk\` inside it to index it anyway.`;
+    case "untracked":
+      return `${result.root ?? "This folder"} is a git repository with no tracked files yet, so it was not indexed. Run \`token-goat index --walk\` inside it, or \`git add\` the files and run \`token-goat index\`.`;
+    case "blocked":
+      return `${result.root ?? "This folder"} is excluded by worker.blocked_roots, so it was not indexed.`;
+    default:
+      return null;
+  }
+}
+
+export {
+  MAX_FILES_SCANNED_FORCED,
+  collectWalkIndexFiles,
+  INSTALL_INDEX_ENV,
+  queueInstallIndex,
+  formatInstallIndexResult
+};