@quolu/lattice 0.1.0 → 0.12.2

package/sensor/dist/extraction/index.js

@@ -88,9 +88,9 @@ const SYNC_RECONCILE_YIELD_INTERVAL = 1000;
  * Maximum time (ms) to wait for a single file to parse in the worker thread.
  * If tree-sitter hangs or WASM runs out of memory, this prevents the entire
  * indexing run from freezing. The worker is restarted after a (hard) timeout.
- * Env-overridable via CODEGRAPH_PARSE_TIMEOUT_MS for slow storage (#1231).
+ * Env-overridable via LATTICE_SENSOR_PARSE_TIMEOUT_MS for slow storage (#1231).
  */
-const PARSE_TIMEOUT_MS = (0, parse_pool_1.resolveParseTimeoutMs)(process.env.CODEGRAPH_PARSE_TIMEOUT_MS);
+const PARSE_TIMEOUT_MS = (0, parse_pool_1.resolveParseTimeoutMs)(process.env.LATTICE_SENSOR_PARSE_TIMEOUT_MS);
 /**
  * Number of files to parse before recycling the worker thread.
  * WASM linear memory can grow but NEVER shrink (WebAssembly spec limitation).
@@ -113,7 +113,7 @@ function hashContent(content) {
 const MAX_FILE_SIZE = 1024 * 1024;
 /**
  * Directory names that are dependency, build, cache, or tooling output across the
- * languages/frameworks CodeGraph supports — curated from the canonical
+ * languages/frameworks LatticeSensor supports — curated from the canonical
  * github/gitignore templates. Excluded by default so the graph reflects your code,
  * not third-party noise, without requiring a `.gitignore` (issue #407). The
  * exclusion applies uniformly (git or not, tracked or not); the only opt-in is an
@@ -122,7 +122,7 @@ const MAX_FILE_SIZE = 1024 * 1024;
  * `Library`) are deliberately NOT listed, to avoid ever hiding real source.
  *
  * Only dirs that actually contain *indexable source* (or are enormous) earn a slot
- * — IDE/state dirs like `.idea`/`.vs` are omitted because CodeGraph indexes only
+ * — IDE/state dirs like `.idea`/`.vs` are omitted because LatticeSensor indexes only
  * recognized source extensions, so they produce no symbols regardless.
  */
 const DEFAULT_IGNORE_DIRS = new Set([
@@ -169,7 +169,7 @@ const DEFAULT_IGNORE_DIRS = new Set([
  * version-qualified (`values-es`, `drawable-hdpi`, `layout-v21`, …). None of it
  * yields an extractable code symbol, yet on an Android app it DOMINATES the tree
  * (one report: 26k XML files = 97% of the project, 0 symbols), bloating the DB,
- * slowing indexing, and skewing both the file count and `codegraph_explore`
+ * slowing indexing, and skewing both the file count and `lattice_sensor_explore`
  * results (#1047). So these are excluded by default. The structure is
  * self-identifying — a non-Android project has no `res/layout/` etc., so it's
  * untouched — and the only XML that DOES produce symbols (MyBatis mappers) lives
@@ -237,7 +237,7 @@ function readGitignorePatterns(giPath) {
     // Fast path: one `.ignores()` call forces the library to compile EVERY rule,
     // so if it doesn't throw, the whole file is safe to use verbatim.
     try {
-        (0, ignore_1.default)().add(content).ignores('.codegraph-probe');
+        (0, ignore_1.default)().add(content).ignores('.lattice/sensor-probe');
         return content;
     }
     catch {
@@ -247,7 +247,7 @@ function readGitignorePatterns(giPath) {
     let dropped = 0;
     for (const line of content.split(/\r?\n/)) {
         try {
-            (0, ignore_1.default)().add(line).ignores('.codegraph-probe');
+            (0, ignore_1.default)().add(line).ignores('.lattice/sensor-probe');
             kept.push(line);
         }
         catch {
@@ -282,7 +282,7 @@ function defaultsOnlyIgnore() {
     return (0, ignore_1.default)().add(DEFAULT_IGNORE_PATTERNS);
 }
 /**
- * Matcher for the project's `codegraph.json` `includeIgnored` patterns — the
+ * Matcher for the project's `lattice-sensor.json` `includeIgnored` patterns — the
  * explicit opt-in to index embedded git repos living inside gitignored
  * directories (#622, #699). Returns `null` when the project opted in nothing,
  * which is the zero-config DEFAULT: `.gitignore` is then fully respected and a
@@ -295,7 +295,7 @@ function loadIncludeIgnoredMatcher(rootDir) {
     return patterns.length > 0 ? (0, ignore_1.default)().add(patterns) : null;
 }
 /**
- * Matcher for the project's `codegraph.json` `exclude` patterns — paths to keep
+ * Matcher for the project's `lattice-sensor.json` `exclude` patterns — paths to keep
  * OUT of the index even when git-tracked, which `.gitignore` cannot do (#999).
  * The escape hatch for a committed vendor/theme/SDK directory. Returns `null`
  * when nothing is excluded (the zero-config default → no overhead). Matched
@@ -308,7 +308,7 @@ function loadExcludeMatcher(rootDir) {
     return patterns.length > 0 ? (0, ignore_1.default)().add(patterns) : null;
 }
 /**
- * Matcher for the project's `codegraph.json` `include` patterns — first-party
+ * Matcher for the project's `lattice-sensor.json` `include` patterns — first-party
  * source to force INTO the index even when `.gitignore` drops it (the general
  * whitelist `includeIgnored` never was — that one only revives *embedded git
  * repos*). The case it exists for: a project under a second VCS (SVN/Perforce)
@@ -374,7 +374,7 @@ function includeStaticRoots(patterns) {
  * A file is collected when it MATCHES `include`, is NOT hit by `exclude` (an
  * explicit exclude always wins), is a recognized source file, and does not live
  * under a built-in default-ignored dir (`node_modules`, `dist`, …), `.git`, or
- * CodeGraph's data dir — those are never resurfaced, mirroring `ScopeIgnore`.
+ * LatticeSensor's data dir — those are never resurfaced, mirroring `ScopeIgnore`.
  * `.gitignore` is deliberately NOT consulted: overriding it is the whole point.
  */
 function collectIncludedFiles(rootDir, include, exclude, roots, overrides) {
@@ -424,7 +424,7 @@ function collectIncludedFiles(rootDir, include, exclude, roots, overrides) {
             return;
         }
         for (const entry of entries) {
-            if (entry.name === '.git' || (0, directory_1.isCodeGraphDataDir)(entry.name))
+            if (entry.name === '.git' || (0, directory_1.isLatticeStateDir)(entry.name))
                 continue;
             const abs = path.join(absDir, entry.name);
             const rel = (0, utils_1.normalizePath)(path.relative(rootDir, abs));
@@ -449,7 +449,7 @@ function collectIncludedFiles(rootDir, include, exclude, roots, overrides) {
     return out;
 }
 /**
- * The included source files (`codegraph.json` `include`) for a scan root, or an
+ * The included source files (`lattice-sensor.json` `include`) for a scan root, or an
  * empty set when nothing is force-included. Centralizes loading the matcher,
  * roots, exclude, and overrides so both enumeration paths (git and filesystem
  * walk) add the same files.
@@ -502,7 +502,7 @@ const EMBEDDED_REPO_SEARCH_ENTRIES = 2000;
  *   super-repo merely hides from git; index it (#193, #514).
  * - A `.git` **file** is a pointer (`gitdir: …`). A git **worktree** points into
  *   the host repo's own `.git/worktrees/<name>`, so it is a second working view
- *   of a repo CodeGraph already indexes — indexing it just duplicates the whole
+ *   of a repo LatticeSensor already indexes — indexing it just duplicates the whole
  *   graph N times; skip it (#848). A **submodule worktree** points into
  *   `.git/modules/<module>/worktrees/<name>` — same duplication, so skip it too
  *   (#945). A **submodule** checkout points into `.git/modules/<module>` (no
@@ -541,7 +541,7 @@ function classifyGitDir(absDir) {
  * Find git repositories nested under `absDir` (inclusive), shallow bounded BFS.
  * Stops descending at each repo root found — contents belong to that repo's own
  * enumeration. Skips default-ignored dirs (`node_modules` can contain `.git`
- * from npm git-dependencies — that never makes it project code) and CodeGraph
+ * from npm git-dependencies — that never makes it project code) and LatticeSensor
  * data dirs. Depth- and entry-capped so a huge ignored tree can't stall the scan.
  */
 function findNestedGitRepos(absDir, relPrefix) {
@@ -577,7 +577,7 @@ function findNestedGitRepos(absDir, relPrefix) {
         for (const entry of entries) {
             if (!entry.isDirectory())
                 continue;
-            if (entry.name === '.git' || (0, directory_1.isCodeGraphDataDir)(entry.name))
+            if (entry.name === '.git' || (0, directory_1.isLatticeStateDir)(entry.name))
                 continue;
             const childRel = rel + entry.name + '/';
             if (defaults.ignores(childRel))
@@ -607,13 +607,13 @@ class ScopeIgnore {
     defaults = defaultsOnlyIgnore();
     constructor(rootMatcher, embedded, 
     /**
-     * Project `codegraph.json` `exclude` patterns (#999), matched against the
+     * Project `lattice-sensor.json` `exclude` patterns (#999), matched against the
      * full root-relative path. Wins over everything else — an explicit user
      * exclude applies even to tracked files and even inside embedded repos.
      */
     exclude = null, 
     /**
-     * Project `codegraph.json` `include` patterns — first-party source forced
+     * Project `lattice-sensor.json` `include` patterns — first-party source forced
      * INTO the index despite `.gitignore`. When a path matches, it is NOT
      * ignored (so the watcher watches it), overriding `.gitignore`/`rootMatcher`
      * — but never `exclude` (checked first) and never a built-in default-ignored
@@ -689,7 +689,7 @@ function buildScopeIgnore(rootDir, embeddedRoots) {
  *      under `node_modules` is never project code; not even an explicit opt-in
  *      revives it (matches `findIgnoredEmbeddedRepos`).
  *   2. The parent repo's own `.gitignore` covers its path and the project did
- *      NOT opt that path in via `codegraph.json` `includeIgnored`. The gitignore
+ *      NOT opt that path in via `lattice-sensor.json` `includeIgnored`. The gitignore
  *      rule is the user's stated intent to keep that path out of scope, exactly
  *      as for an UNtracked embedded repo — respect it by default, opt back in
  *      with `includeIgnored` (#514, #970, #976).
@@ -710,7 +710,7 @@ function gitlinkEmbeddedRepoSkipped(relDir, prefix, defaults, repoIgnore, includ
 /**
  * Standalone discovery of every embedded repo root under `rootDir` (relative,
  * trailing-slashed) — the untracked kind (#193) always, and the gitignored kind
- * (#514) only for directories the project opted in via `codegraph.json`
+ * (#514) only for directories the project opted in via `lattice-sensor.json`
  * `includeIgnored` (#622, #699); otherwise `.gitignore` is respected and they
  * are not discovered (#970, #976). Recursive (an embedded repo can embed further
  * repos). Returns [] for non-git roots: the filesystem walk handles nested repos
@@ -781,7 +781,7 @@ const UNINDEXED_IGNORED_REPO_HINT_CAP = 100;
 /**
  * The INVERSE of the gitignored side of {@link discoverEmbeddedRepoRoots}:
  * nested git repositories under a gitignored directory that the project has NOT
- * opted into via `codegraph.json` `includeIgnored`. These are real repos the
+ * opted into via `lattice-sensor.json` `includeIgnored`. These are real repos the
  * default `init`/`index` deliberately skips because `.gitignore` excludes them
  * (#970, #976) — most visibly the "super-repo `.gitignore`s its child repos"
  * layout (#1156), where `init` at the parent correctly indexes ~nothing while
@@ -827,9 +827,9 @@ function findUnindexedIgnoredRepos(rootDir) {
  * relative to `repoDir`, trailing-slashed.
  *
  * OPT-IN ONLY. Walking into a gitignored directory contradicts what every other
- * tool (and CodeGraph's own `git ls-files` foundation) does — `.gitignore`
+ * tool (and LatticeSensor's own `git ls-files` foundation) does — `.gitignore`
  * excludes. So this returns `[]` unless the project opted the directory in via
- * `codegraph.json` `includeIgnored`; without that, a gitignored dir — including
+ * `lattice-sensor.json` `includeIgnored`; without that, a gitignored dir — including
  * a huge reference/data dir full of nested clones — is left untouched (#970,
  * #976). When opted in, it restores the super-repo-of-clones behavior (#622,
  * #699). `prefix` is the scan-root-relative path of `repoDir`, so a pattern like
@@ -876,7 +876,7 @@ function findIgnoredEmbeddedRepos(repoDir, includeIgnored, prefix) {
  * embedded repo is its own git boundary, so we re-run `git ls-files` inside it.
  * (See issue #193.) GITIGNORED embedded repos are invisible even to that; they
  * are discovered separately via `findIgnoredEmbeddedRepos` (#514) but ONLY for
- * directories the project opted in through `codegraph.json` `includeIgnored`
+ * directories the project opted in through `lattice-sensor.json` `includeIgnored`
  * (`includeIgnored` here, threaded from the scan root) — by default `.gitignore`
  * is respected and they stay out (#970, #976). Every embedded repo root (however
  * found) is recorded in `embeddedRoots` so callers can exempt its files from the
@@ -974,7 +974,7 @@ function collectGitFiles(repoDir, prefix, files, embeddedRoots, includeIgnored =
     // Embedded repos hidden by THIS repo's ignore rules (`/packages/` in a
     // super-repo .gitignore) never appear in any listing above. By default they
     // stay hidden — `.gitignore` is respected (#970, #976). They are recursed into
-    // only when the project opted the directory in via `codegraph.json`
+    // only when the project opted the directory in via `lattice-sensor.json`
     // `includeIgnored` (#622, #699), which `findIgnoredEmbeddedRepos` enforces.
     for (const rel of findIgnoredEmbeddedRepos(repoDir, includeIgnored, prefix)) {
         embeddedRoots?.add((0, utils_1.normalizePath)(prefix + rel));
@@ -1016,7 +1016,7 @@ function getGitVisibleFiles(rootDir) {
         const ig = buildScopeIgnore(rootDir, embeddedRoots);
         const visible = new Set([...files].filter((f) => !ig.ignores(f)));
         // Force-include first-party source the project whitelisted in
-        // `codegraph.json` `include`. These are gitignored, so `git ls-files` never
+        // `lattice-sensor.json` `include`. These are gitignored, so `git ls-files` never
         // listed them above — discover them directly off disk and add them. (The
         // common SVN+Git dual-VCS case: source committed to SVN, gitignored out of
         // Git, but still wanted in the graph.)
@@ -1035,17 +1035,17 @@ function getGitVisibleFiles(rootDir) {
  * Recurses into embedded repos — the untracked kind (#193: the parent's status
  * collapses them to an opaque `?? subdir/` entry) always, and the gitignored
  * kind (#514: they never appear in the parent's status at all) only for
- * directories opted in via `codegraph.json` `includeIgnored` (#622, #699) —
+ * directories opted in via `lattice-sensor.json` `includeIgnored` (#622, #699) —
  * running `git status` inside each, so changes in a multi-repo workspace sync
  * without a full rescan. By default a gitignored dir is left alone, matching the
  * full-index scan (#970, #976). Deleting an ENTIRE embedded repo dir is the one
  * case this cannot see (the child status that would report the deletions is gone
- * with it); a full `codegraph index` reconciles that.
+ * with it); a full `lattice sensor index` reconciles that.
  */
 function getGitChangedFiles(rootDir) {
     try {
         const changes = { modified: [], added: [], deleted: [] };
-        // Custom extension → language overrides from the project's codegraph.json,
+        // Custom extension → language overrides from the project's lattice-sensor.json,
         // so change detection sees the same custom-extension files the full index does.
         const overrides = (0, project_config_1.loadExtensionOverrides)(rootDir);
         collectGitStatus(rootDir, '', changes, overrides, loadIncludeIgnoredMatcher(rootDir), loadExcludeMatcher(rootDir));
@@ -1062,7 +1062,7 @@ function collectGitStatus(repoDir, prefix, out, overrides, includeIgnored = null
     // status hides neither: it ignores nothing for *tracked* paths, and the
     // built-in defaults aren't gitignore at all. Without this filter a committed
     // vendor/ dir, or a tracked file under a .gitignored dir, surfaces here as a
-    // change — so `codegraph status` (which reads getChangedFiles) reports a
+    // change — so `lattice sensor status` (which reads getChangedFiles) reports a
     // pending edit the full index never tracks and `sync` never clears. Matching
     // repo-relative `rel` at each recursion level mirrors getGitVisibleFiles'
     // ScopeIgnore: every embedded repo is judged by ITS OWN rules, never the
@@ -1094,7 +1094,7 @@ function collectGitStatus(repoDir, prefix, out, overrides, includeIgnored = null
         // index — match against the repo-relative path, same as the full scan. (#766)
         if (ig.ignores(rel))
             continue;
-        // User `codegraph.json` `exclude` (#999) is project-root-relative, so it's
+        // User `lattice-sensor.json` `exclude` (#999) is project-root-relative, so it's
         // matched against the full path — sync must not re-add a tracked file the
         // full index now keeps out. Deletions above stay unfiltered so a file that
         // WAS indexed before an exclude was added still cleans itself out.
@@ -1129,7 +1129,7 @@ function collectGitStatus(repoDir, prefix, out, overrides, includeIgnored = null
  * projects, falls back to a filesystem walk that parses .gitignore itself.
  */
 function scanDirectory(rootDir, onProgress) {
-    // Custom extension → language overrides from the project's codegraph.json.
+    // Custom extension → language overrides from the project's lattice-sensor.json.
     const overrides = (0, project_config_1.loadExtensionOverrides)(rootDir);
     // Fast path: use git to get all visible files (respects .gitignore everywhere)
     const gitFiles = getGitVisibleFiles(rootDir);
@@ -1153,7 +1153,7 @@ function scanDirectory(rootDir, onProgress) {
  * allowing worker threads to receive and render progress messages.
  */
 async function scanDirectoryAsync(rootDir, onProgress) {
-    // Custom extension → language overrides from the project's codegraph.json.
+    // Custom extension → language overrides from the project's lattice-sensor.json.
     const overrides = (0, project_config_1.loadExtensionOverrides)(rootDir);
     const gitFiles = getGitVisibleFiles(rootDir);
     if (gitFiles) {
@@ -1181,7 +1181,7 @@ function scanDirectoryWalk(rootDir, onProgress) {
     const files = [];
     let count = 0;
     const visitedDirs = new Set();
-    // Custom extension → language overrides from the project's codegraph.json.
+    // Custom extension → language overrides from the project's lattice-sensor.json.
     const overrides = (0, project_config_1.loadExtensionOverrides)(rootDir);
     const loadIgnore = (dir) => {
         const giPath = path.join(dir, '.gitignore');
@@ -1233,9 +1233,9 @@ function scanDirectoryWalk(rootDir, onProgress) {
             return;
         }
         for (const entry of entries) {
-            // Never descend into git internals or any CodeGraph data directory
+            // Never descend into git internals or any LatticeSensor data directory
             // (the active one or a sibling another environment created — #636).
-            if (entry.name === '.git' || (0, directory_1.isCodeGraphDataDir)(entry.name))
+            if (entry.name === '.git' || (0, directory_1.isLatticeStateDir)(entry.name))
                 continue;
             const fullPath = path.join(dir, entry.name);
             const relativePath = (0, utils_1.normalizePath)(path.relative(rootDir, fullPath));
@@ -1278,14 +1278,14 @@ function scanDirectoryWalk(rootDir, onProgress) {
     // Seed a base matcher with the built-in default ignores (merged with the root
     // .gitignore so a negation can override). Nested .gitignores still layer per-dir.
     const baseMatchers = [{ dir: rootDir, ig: buildDefaultIgnore(rootDir) }];
-    // Project `codegraph.json` `exclude` patterns (#999), rooted at the project so
+    // Project `lattice-sensor.json` `exclude` patterns (#999), rooted at the project so
     // `isIgnored` matches them against root-relative paths — same coverage the
     // git path gets via ScopeIgnore, for non-git projects.
     const exclude = loadExcludeMatcher(rootDir);
     if (exclude)
         baseMatchers.push({ dir: rootDir, ig: exclude });
     walk(rootDir, baseMatchers);
-    // Force-include first-party source whitelisted in `codegraph.json` `include`
+    // Force-include first-party source whitelisted in `lattice-sensor.json` `include`
     // — the walk above honours `.gitignore`, so anything gitignored was dropped;
     // add it back here (deduped). Mirrors the git path's union.
     const included = collectIncludedFilesForRoot(rootDir);
@@ -1436,7 +1436,7 @@ class ExtractionOrchestrator {
     storeWriterOpts) {
         const tGrammar = Date.now();
         await (0, grammars_1.initGrammars)();
-        if (process.env.CODEGRAPH_SYNTH_TIMINGS)
+        if (process.env.LATTICE_SENSOR_SYNTH_TIMINGS)
             console.error(`[phase-timing] grammar-init: ${Date.now() - tGrammar}ms`);
         const startTime = Date.now();
         const errors = [];
@@ -1445,7 +1445,7 @@ class ExtractionOrchestrator {
         let filesErrored = 0;
         let totalNodes = 0;
         let totalEdges = 0;
-        // Custom extension → language overrides from the project's codegraph.json.
+        // Custom extension → language overrides from the project's lattice-sensor.json.
         // Threaded into language detection so custom-extension files load the right
         // grammar and store under the mapped language.
         const overrides = (0, project_config_1.loadExtensionOverrides)(this.rootDir);
@@ -1470,7 +1470,7 @@ class ExtractionOrchestrator {
                 currentFile: file,
             });
         });
-        if (process.env.CODEGRAPH_SYNTH_TIMINGS)
+        if (process.env.LATTICE_SENSOR_SYNTH_TIMINGS)
             console.error(`[phase-timing] scan: ${Date.now() - tScan}ms (${files.length} files)`);
         // Detect frameworks once per indexAll run using the scanned file list.
         // Names are passed to each parse call so framework-specific extractors
@@ -1480,7 +1480,7 @@ class ExtractionOrchestrator {
         this.detectedFrameworkNames = null;
         const tFw = Date.now();
         const frameworkNames = this.ensureDetectedFrameworks(files);
-        if (process.env.CODEGRAPH_SYNTH_TIMINGS)
+        if (process.env.LATTICE_SENSOR_SYNTH_TIMINGS)
             console.error(`[phase-timing] framework-detect: ${Date.now() - tFw}ms`);
         if (signal?.aborted) {
             return {
@@ -1519,9 +1519,9 @@ class ExtractionOrchestrator {
         const useWorker = fs.existsSync(parseWorkerPath);
         let pool = null;
         if (useWorker) {
-            // CODEGRAPH_PARSE_WORKERS: explicit worker count; 1 = the old single-worker
+            // LATTICE_SENSOR_PARSE_WORKERS: explicit worker count; 1 = the old single-worker
             // behaviour (the conservative rollback). Unset → clamp(cores-1, 1, 8).
-            const poolSize = (0, parse_pool_1.resolveParsePoolSize)(process.env.CODEGRAPH_PARSE_WORKERS, os.cpus().length);
+            const poolSize = (0, parse_pool_1.resolveParsePoolSize)(process.env.LATTICE_SENSOR_PARSE_WORKERS, os.cpus().length);
             // Read each needed grammar's WASM ONCE here and hand the bytes to every
             // worker, so spawns/respawns load grammars from memory instead of
             // re-reading them from disk (#1231: on an HDD, respawn re-reads amplify
@@ -1552,7 +1552,7 @@ class ExtractionOrchestrator {
         const storeWorkerPath = path.join(__dirname, 'store-worker.js');
         let storeWriter = null;
         if (storeWriterOpts &&
-            process.env.CODEGRAPH_NO_STORE_WORKER !== '1' &&
+            process.env.LATTICE_SENSOR_NO_STORE_WORKER !== '1' &&
             fs.existsSync(storeWorkerPath)) {
             // Deliberately NOT awaiting ready(): worker_threads delivers messages in
             // order, so bundles posted while the worker is still booting queue
@@ -1567,7 +1567,7 @@ class ExtractionOrchestrator {
          * Parse one file: on the pool when available (the promise REJECTS on a worker
          * crash/timeout — the caller records it and the retry pass re-attempts), or
          * in-process synchronously as the no-worker fallback. The language is resolved
-         * here on the main thread, where the codegraph.json overrides are loaded.
+         * here on the main thread, where the lattice-sensor.json overrides are loaded.
          */
         const parseFile = (filePath, content) => {
             const language = (0, grammars_1.detectLanguage)(filePath, content, overrides);
@@ -1831,7 +1831,7 @@ class ExtractionOrchestrator {
                 }
             }
         }
-        if (process.env.CODEGRAPH_SYNTH_TIMINGS)
+        if (process.env.LATTICE_SENSOR_SYNTH_TIMINGS)
             console.error(`[phase-timing] parse-loop: ${Date.now() - tParseLoop}ms`);
         if (signal?.aborted || aborted) {
             if (storeWriter)
@@ -2097,7 +2097,7 @@ class ExtractionOrchestrator {
                 durationMs: 0,
             };
         }
-        // Detect language (honoring the project's codegraph.json extension overrides)
+        // Detect language (honoring the project's lattice-sensor.json extension overrides)
         const language = (0, grammars_1.detectLanguage)(relativePath, content, (0, project_config_1.loadExtensionOverrides)(this.rootDir));
         if (!(0, grammars_1.isLanguageSupported)(language)) {
             return {
@@ -2340,13 +2340,13 @@ class ExtractionOrchestrator {
         // cannot see, because the working tree is clean afterward.
         const tSyncScan = Date.now();
         const currentFiles = await scanDirectoryAsync(this.rootDir);
-        if (process.env.CODEGRAPH_SYNTH_TIMINGS)
+        if (process.env.LATTICE_SENSOR_SYNTH_TIMINGS)
             console.error(`[phase-timing] sync-scan: ${Date.now() - tSyncScan}ms (${currentFiles.length} files)`);
         filesChecked = currentFiles.length;
         const currentSet = new Set(currentFiles);
         const tTracked = Date.now();
         const trackedFiles = this.queries.getAllFiles();
-        if (process.env.CODEGRAPH_SYNTH_TIMINGS)
+        if (process.env.LATTICE_SENSOR_SYNTH_TIMINGS)
             console.error(`[phase-timing] sync-tracked-load: ${Date.now() - tTracked}ms (${trackedFiles.length} tracked)`);
         const trackedMap = new Map();
         for (const f of trackedFiles) {