@quolu/lattice 0.1.0 → 0.12.2

package/sensor/dist/mcp/tools.js

@@ -2,7 +2,7 @@
 /**
  * MCP Tool Definitions
  *
- * Defines the tools exposed by the CodeGraph MCP server.
+ * Defines the tools exposed by the LatticeSensor MCP server.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ToolHandler = exports.tools = exports.IndexOpenError = exports.PathRefusalError = exports.NotIndexedError = void 0;
@@ -15,12 +15,12 @@ exports.formatDegradedBanner = formatDegradedBanner;
 exports.getStaticTools = getStaticTools;
 const directory_1 = require("../directory");
 const version_1 = require("./version");
-// Lazy-load the heavy CodeGraph chain off the MCP startup path — see the same
+// Lazy-load the heavy LatticeSensor chain off the MCP startup path — see the same
 // helper in engine.ts. ToolHandler must load to answer tools/list (static
 // schemas), but it must NOT drag in sqlite/query layers before the daemon binds;
-// CodeGraph is pulled in only when a tool actually opens a project. require() is
+// LatticeSensor is pulled in only when a tool actually opens a project. require() is
 // sync + cached (CommonJS build).
-const loadCodeGraph = () => require('../index').default;
+const loadLatticeSensor = () => require('../index').default;
 const worktree_1 = require("../sync/worktree");
 const query_utils_1 = require("../search/query-utils");
 const fs_1 = require("fs");
@@ -28,11 +28,11 @@ const utils_1 = require("../utils");
 const generated_detection_1 = require("../extraction/generated-detection");
 const dynamic_boundaries_1 = require("./dynamic-boundaries");
 /**
- * An expected, recoverable "codegraph can't serve this" condition — most
+ * An expected, recoverable "lattice sensor can't serve this" condition — most
  * importantly a project with no index. The dispatch catch converts these to
  * SUCCESS-shaped responses (guidance text, NO isError): an `isError: true`
  * early in a session teaches the agent the toolset is broken and it stops
- * calling codegraph entirely (observed repeatedly), which is exactly wrong
+ * calling lattice sensor entirely (observed repeatedly), which is exactly wrong
  * for conditions the agent can simply work around (use built-in tools for
  * that codebase / pass projectPath). isError is reserved for "stop trying"
  * cases: security refusals ({@link PathRefusalError}) and genuine
@@ -51,13 +51,13 @@ exports.PathRefusalError = PathRefusalError;
 /**
  * ADR 0049 Decision 5②: a genuine malfunction opening the default project's
  * index — DB open failure, schema mismatch, integrity error, or lock
- * contention — as OPPOSED to the project simply having no `.codegraph/` at
+ * contention — as OPPOSED to the project simply having no `.lattice/sensor/` at
  * all (that stays {@link NotIndexedError}, the success-shaped guidance case).
  * This is fail-closed by design: it stays `isError: true` (via `execute`'s
  * catch, same as {@link PathRefusalError}) rather than the NotIndexedError
  * success-shaped guidance, because silently degrading to "no default
  * project" here would hide a broken index behind text that reads as "just
- * run `codegraph init`" — actively misleading for a project that WAS
+ * run `lattice sensor init . --json`" — actively misleading for a project that WAS
  * indexed and IS now broken.
  */
 class IndexOpenError extends Error {
@@ -89,7 +89,7 @@ const MAX_PATH_LENGTH = 4_096;
  */
 const RUST_PATH_PREFIXES = new Set(['crate', 'super', 'self']);
 /**
- * Node kinds that contain other symbols. For these, `codegraph_node` with
+ * Node kinds that contain other symbols. For these, `lattice_sensor_node` with
  * `includeCode=true` returns a structural outline (member names + signatures
  * + line numbers) instead of the full body, which for a large class is a
  * multi-thousand-character wall of source that bloats the agent's context.
@@ -129,7 +129,7 @@ function normalizeQuerySpelling(query) {
         .replace(/(^|[\s,()[\]])(?!(?:kind|lang|language|path|name):)([a-z_][\w@]*):([A-Za-z_][\w@]*)(?=$|[\s,()[\]])/g, '$1$2.$3');
 }
 /**
- * Calculate the recommended number of codegraph_explore calls based on project size.
+ * Calculate the recommended number of lattice_sensor_explore calls based on project size.
  * Larger codebases need more exploration calls to cover their surface area,
  * but smaller ones should use fewer to avoid unnecessary overhead.
  */
@@ -244,21 +244,21 @@ function getExploreOutputBudget(fileCount) {
     };
 }
 /**
- * Whether `codegraph_explore` should prefix source lines with their line
+ * Whether `lattice_sensor_explore` should prefix source lines with their line
  * numbers (cat -n style: `<num>\t<code>`).
  *
  * Line numbers let the agent cite `file:line` straight from the explore
  * payload instead of re-Reading the file just to find a line number — the
  * dominant residual cost on precise-tracing questions (#185 follow-up).
  *
- * Defaults ON. Set `CODEGRAPH_EXPLORE_LINENUMS=0` to disable (used by the
+ * Defaults ON. Set `LATTICE_SENSOR_EXPLORE_LINENUMS=0` to disable (used by the
  * A/B harness to measure the payload-cost vs. read-savings tradeoff).
  */
 function exploreLineNumbersEnabled() {
-    return process.env.CODEGRAPH_EXPLORE_LINENUMS !== '0';
+    return process.env.LATTICE_SENSOR_EXPLORE_LINENUMS !== '0';
 }
 /**
- * Adaptive explore sizing (default ON). `codegraph_explore` skeletonizes OFF-SPINE
+ * Adaptive explore sizing (default ON). `lattice_sensor_explore` skeletonizes OFF-SPINE
  * polymorphic-sibling files — a file whose class is one of ≥3 interchangeable
  * implementations of a shared interface (e.g. OkHttp's `: Interceptor` classes) —
  * to class + member signatures (bodies elided), keeping the on-spine exemplar full.
@@ -267,10 +267,10 @@ function exploreLineNumbersEnabled() {
  * search, reads flat). It is PROVABLY INERT elsewhere: distinct pipeline steps (no
  * ≥3-implementer supertype, e.g. Excalidraw's `renderStaticScene`) and on-spine
  * files keep full source — output is byte-identical to shipped on excalidraw /
- * tokio / django / vscode / gin. Set `CODEGRAPH_ADAPTIVE_EXPLORE=0` to disable.
+ * tokio / django / vscode / gin. Set `LATTICE_SENSOR_ADAPTIVE_EXPLORE=0` to disable.
  */
 function adaptiveExploreEnabled() {
-    return process.env.CODEGRAPH_ADAPTIVE_EXPLORE !== '0' && process.env.CODEGRAPH_ADAPTIVE_EXPLORE !== 'false';
+    return process.env.LATTICE_SENSOR_ADAPTIVE_EXPLORE !== '0' && process.env.LATTICE_SENSOR_ADAPTIVE_EXPLORE !== 'false';
 }
 /**
  * How long the FIRST tool call waits on the post-open catch-up reconcile before
@@ -281,12 +281,12 @@ function adaptiveExploreEnabled() {
  * for a clean answer, then serve and let the reconcile finish in the background
  * (it yields to the event loop, so a concurrent read still runs).
  *
- * `CODEGRAPH_CATCHUP_GATE_TIMEOUT_MS` overrides the default; `0` restores the
+ * `LATTICE_SENSOR_CATCHUP_GATE_TIMEOUT_MS` overrides the default; `0` restores the
  * old unbounded-wait behavior (always block until the reconcile completes).
  */
 const DEFAULT_CATCHUP_GATE_TIMEOUT_MS = 3000;
 function resolveCatchUpGateTimeoutMs() {
-    const raw = process.env.CODEGRAPH_CATCHUP_GATE_TIMEOUT_MS;
+    const raw = process.env.LATTICE_SENSOR_CATCHUP_GATE_TIMEOUT_MS;
     if (raw === undefined || raw === '')
         return DEFAULT_CATCHUP_GATE_TIMEOUT_MS;
     const n = Number(raw);
@@ -311,7 +311,7 @@ function numberSourceLines(slice, firstLineNumber) {
     return out.join('\n');
 }
 /**
- * Unique line-prefix for a per-file source section in codegraph_explore output.
+ * Unique line-prefix for a per-file source section in lattice_sensor_explore output.
  * Issue #778: tool results dropped ATX headings (`####`, `##`, `###`) for bold
  * labels so Markdown-rendering MCP clients (e.g. the Claude Code VSCode
  * extension) stop blowing every header up to H1–H4. The path is bold + a code
@@ -320,12 +320,12 @@ function numberSourceLines(slice, firstLineNumber) {
  * truncation boundary (`handleExplore`) keys off to cut on whole file sections.
  */
 const FILE_SECTION_PREFIX = '**`';
-// Placeholder for codegraph_explore's "Found N symbols across M files." line.
+// Placeholder for lattice_sensor_explore's "Found N symbols across M files." line.
 // The honest N/M can only be known after the final truncation drops trailing
 // sections (#1046), so the header is emitted as this sentinel and substituted
 // at the very end. This bracketed token never occurs in rendered source or a
 // file path, so the final string-replace can't collide.
-const SUMMARY_SENTINEL = '[[codegraph-explore-summary]]';
+const SUMMARY_SENTINEL = '[[lattice sensor-explore-summary]]';
 function fileSectionHeader(filePath, suffix) {
     return suffix
         ? `${FILE_SECTION_PREFIX}${filePath}\`** — ${suffix}`
@@ -345,7 +345,7 @@ function formatStaleBanner(stale) {
         return `  - ${p.path} (edited ${ageMs}ms ago, ${label})`;
     });
     return ('⚠️ Some files referenced below were edited since the last index sync — ' +
-        'their codegraph entries may be stale:\n' +
+        'their lattice sensor entries may be stale:\n' +
         lines.join('\n') +
         '\nFor accurate content of those specific files, Read them directly. ' +
         'The rest of this response is fresh.');
@@ -373,10 +373,10 @@ function formatStaleFooter(stale) {
  * `getPendingFiles()` is empty, so the per-file banner above can't fire even
  * though the index is now FROZEN and silently drifting stale. Leads with the
  * agent-actionable instruction (Read directly) and carries the reason, which
- * already names the operator remedy (`codegraph sync` / git hooks).
+ * already names the operator remedy (`lattice sensor sync . --json` / git hooks).
  */
 function formatDegradedBanner(reason) {
-    return ('⚠️ CodeGraph auto-sync is DISABLED — live file watching stopped, so the index is ' +
+    return ('⚠️ LatticeSensor auto-sync is DISABLED — live file watching stopped, so the index is ' +
         'frozen and any file edited since then is stale here. Read files directly to confirm ' +
         'current content before relying on it.' +
         (reason ? `\n  Reason: ${reason}` : ''));
@@ -386,10 +386,10 @@ function formatDegradedBanner(reason) {
  */
 const projectPathProperty = {
     type: 'string',
-    description: 'Absolute path to the project to query (or any directory inside it) — codegraph uses the nearest .codegraph/ index at or above that path. Omit to use this session\'s default project. Pass it to query a second codebase, or when the server root has no index of its own (e.g. a monorepo where only sub-projects are indexed, so there is no default project).',
+    description: 'Absolute path to the project to query (or any directory inside it) — lattice sensor uses the nearest .lattice/sensor/ index at or above that path. Omit to use this session\'s default project. Pass it to query a second codebase, or when the server root has no index of its own (e.g. a monorepo where only sub-projects are indexed, so there is no default project).',
 };
 /**
- * EVERY codegraph tool is query-only: it reads the pre-built index and never
+ * EVERY lattice sensor tool is query-only: it reads the pre-built index and never
  * mutates the workspace (indexing is the user's explicit CLI call, never the
  * agent's). Advertising this read-only contract lets clients that gate on it run
  * the tools where a possibly-mutating tool would be blocked — most concretely,
@@ -406,9 +406,9 @@ const READ_ONLY_ANNOTATIONS = {
     openWorldHint: false,
 };
 /**
- * All CodeGraph MCP tools
+ * All LatticeSensor MCP tools
  *
- * Designed for minimal context usage - use codegraph_explore as the primary tool
+ * Designed for minimal context usage - use lattice_sensor_explore as the primary tool
  * (one call usually answers the whole question), and only use other tools for
  * targeted follow-up queries.
  *
@@ -416,8 +416,8 @@ const READ_ONLY_ANNOTATIONS = {
  */
 exports.tools = [
     {
-        name: 'codegraph_search',
-        description: 'Quick symbol search by name. Returns locations only (no code). Use codegraph_explore instead to get the actual source / understand an area in one call.',
+        name: 'lattice_sensor_search',
+        description: 'Quick symbol search by name. Returns locations only (no code). Use lattice_sensor_explore instead to get the actual source / understand an area in one call.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -442,8 +442,8 @@ exports.tools = [
         annotations: READ_ONLY_ANNOTATIONS,
     },
     {
-        name: 'codegraph_callers',
-        description: 'List functions that call <symbol>. For the full flow, use codegraph_explore.',
+        name: 'lattice_sensor_callers',
+        description: 'List functions that call <symbol>. For the full flow, use lattice_sensor_explore.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -467,8 +467,8 @@ exports.tools = [
         annotations: READ_ONLY_ANNOTATIONS,
     },
     {
-        name: 'codegraph_callees',
-        description: 'List functions that <symbol> calls. For the full flow, use codegraph_explore.',
+        name: 'lattice_sensor_callees',
+        description: 'List functions that <symbol> calls. For the full flow, use lattice_sensor_explore.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -492,7 +492,7 @@ exports.tools = [
         annotations: READ_ONLY_ANNOTATIONS,
     },
     {
-        name: 'codegraph_impact',
+        name: 'lattice_sensor_impact',
         description: 'List symbols affected by changing <symbol>. Use before a refactor.',
         inputSchema: {
             type: 'object',
@@ -517,8 +517,8 @@ exports.tools = [
         annotations: READ_ONLY_ANNOTATIONS,
     },
     {
-        name: 'codegraph_node',
-        description: 'Two modes. (1) READ A FILE — use INSTEAD of the Read tool: pass `file` (a path or basename) with no `symbol` and it returns that file\'s current on-disk source with line numbers, exactly the shape Read gives you (`<n>\\t<line>`, safe to Edit from), narrowable with `offset`/`limit` just like Read — PLUS a one-line note of which files depend on it. Same bytes as Read, faster (served from the index), with the blast radius attached. Use it whenever you would Read a source file. (2) ONE SYMBOL you can name — its location, signature, verbatim source (includeCode=true) and caller/callee trail in one call, so before changing it you see what calls it and what your edit would break. For an AMBIGUOUS name it returns EVERY matching definition\'s body in one call (so you never Read a file to find the right overload); pass `file`/`line` to pin one. Use codegraph_explore for several related symbols or the full flow.',
+        name: 'lattice_sensor_node',
+        description: 'Two modes. (1) READ A FILE — use INSTEAD of the Read tool: pass `file` (a path or basename) with no `symbol` and it returns that file\'s current on-disk source with line numbers, exactly the shape Read gives you (`<n>\\t<line>`, safe to Edit from), narrowable with `offset`/`limit` just like Read — PLUS a one-line note of which files depend on it. Same bytes as Read, faster (served from the index), with the blast radius attached. Use it whenever you would Read a source file. (2) ONE SYMBOL you can name — its location, signature, verbatim source (includeCode=true) and caller/callee trail in one call, so before changing it you see what calls it and what your edit would break. For an AMBIGUOUS name it returns EVERY matching definition\'s body in one call (so you never Read a file to find the right overload); pass `file`/`line` to pin one. Use lattice_sensor_explore for several related symbols or the full flow.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -559,14 +559,14 @@ exports.tools = [
         annotations: READ_ONLY_ANNOTATIONS,
     },
     {
-        name: 'codegraph_explore',
+        name: 'lattice_sensor_explore',
         description: 'PRIMARY TOOL — call FIRST for almost any question OR before an edit: how does X work, architecture, a bug, where/what is X, surveying an area, or the symbols you are about to change. Returns the verbatim source of the relevant symbols grouped by file in ONE capped call (Read-equivalent — treat the shown source as already Read; do NOT re-open those files), plus the call path among them. Query can be a natural-language question OR a bag of symbol/file names. Usually the ONLY call you need — more accurate context, in far fewer tokens and round-trips than a search/Read/Grep loop.',
         inputSchema: {
             type: 'object',
             properties: {
                 query: {
                     type: 'string',
-                    description: 'Symbol names, file names, or short code terms to explore (e.g., "AuthService loginUser session-manager", "GraphTraverser BFS impact traversal.ts"). For a flow question, name the symbols spanning the flow (e.g. "mutateElement renderScene"). A natural-language question works too — no prior codegraph_search needed.',
+                    description: 'Symbol names, file names, or short code terms to explore (e.g., "AuthService loginUser session-manager", "GraphTraverser BFS impact traversal.ts"). For a flow question, name the symbols spanning the flow (e.g. "mutateElement renderScene"). A natural-language question works too — no prior lattice_sensor_search needed.',
                 },
                 maxFiles: {
                     type: 'number',
@@ -580,7 +580,7 @@ exports.tools = [
         annotations: READ_ONLY_ANNOTATIONS,
     },
     {
-        name: 'codegraph_status',
+        name: 'lattice_sensor_status',
         description: 'Index health check (files / nodes / edges) AND the version/execution-mode declaration surface: reports the running Lattice sensor version, the index schema stats, and a machine-readable `mode: daemon|direct` + `reason` field describing how this session is served (see ADR 0049). Skip unless debugging.',
         inputSchema: {
             type: 'object',
@@ -591,7 +591,7 @@ exports.tools = [
         annotations: READ_ONLY_ANNOTATIONS,
     },
     {
-        name: 'codegraph_files',
+        name: 'lattice_sensor_files',
         description: 'Indexed file tree with language + symbol counts. Faster than Glob for project layout.',
         inputSchema: {
             type: 'object',
@@ -630,7 +630,7 @@ exports.tools = [
  *
  * Used for the NO-DEFAULT-PROJECT tool surface (issue #993): when the MCP server
  * has no default project to fall back to — a gateway server started outside any
- * repo, or a monorepo root whose `.codegraph/` indexes live only in sub-projects
+ * repo, or a monorepo root whose `.lattice/sensor/` indexes live only in sub-projects
  * — every call MUST carry an explicit `projectPath`, so the schema should say so.
  * A `required` field is a HIGH-salience channel (MCP clients surface and often
  * validate it), unlike the instructions text the reporter found too weak to stop
@@ -659,45 +659,41 @@ function withRequiredProjectPath(defs) {
 /**
  * Allowlist-filtered tool definitions WITHOUT an engine — the static surface the
  * proxy answers `tools/list` with before any project is open. Mirrors
- * `ToolHandler.getTools()` in the no-CodeGraph case (the dynamic per-repo budget
+ * `ToolHandler.getTools()` in the no-LatticeSensor case (the dynamic per-repo budget
  * note in a description only adds once `cg` is loaded; the schemas are static).
  */
 function getStaticTools() {
-    const raw = process.env.CODEGRAPH_MCP_TOOLS;
+    const raw = process.env.LATTICE_SENSOR_MCP_TOOLS;
     if (!raw || !raw.trim()) {
-        return exports.tools.filter(t => DEFAULT_MCP_TOOLS.has(t.name.replace(/^codegraph_/, '')));
+        return exports.tools.filter(t => DEFAULT_MCP_TOOLS.has(t.name.replace(/^lattice_sensor_/, '')));
     }
-    const allow = new Set(raw.split(',').map(s => s.trim().replace(/^codegraph_/, '')).filter(Boolean));
-    return allow.size ? exports.tools.filter(t => allow.has(t.name.replace(/^codegraph_/, ''))) : exports.tools;
+    const allow = new Set(raw.split(',').map(s => s.trim().replace(/^lattice_sensor_/, '')).filter(Boolean));
+    return allow.size ? exports.tools.filter(t => allow.has(t.name.replace(/^lattice_sensor_/, ''))) : exports.tools;
 }
 /**
- * The MCP tools served by DEFAULT (short names). Pared to ONLY `codegraph_explore`
- * — the single tool that reliably earns its place: one capped call returns the
- * verbatim source of the relevant symbols grouped by file. Every other tool is a
- * narrower slice of what explore already does, and presence itself steers
- * mis-picks, so they are no longer LISTED to agents.
- *
- * The other defined tools (`node`, `search`, `callers`, plus callees/impact/files/
- * status) remain fully functional — handlers stay, the library API and CLI are
- * untouched, and `CODEGRAPH_MCP_TOOLS=explore,node,...` re-enables any of them.
+ * ADR 0049 / 0059: Lattice MCP v1 publishes exactly these eight compatibility
+ * tool names. The provider is Lattice; narrowing the default based on repo size
+ * would silently remove contracted surfaces and make host acceptance ambiguous.
  */
-const DEFAULT_MCP_TOOLS = new Set(['explore']);
+const DEFAULT_MCP_TOOLS = new Set([
+    'search', 'callers', 'callees', 'impact', 'node', 'explore', 'status', 'files',
+]);
 /**
- * Tool handler that executes tools against a CodeGraph instance
+ * Tool handler that executes tools against a LatticeSensor instance
  *
  * Supports cross-project queries via the projectPath parameter.
  * Other projects are opened on-demand and cached for performance.
  */
 class ToolHandler {
     cg;
-    // Cache of opened CodeGraph instances for cross-project queries
+    // Cache of opened LatticeSensor instances for cross-project queries
     projectCache = new Map();
     // The directory the server last searched for a default project. Surfaced in
     // the "not initialized" error so users can see why detection missed.
     defaultProjectHint = null;
     // Per-start-path cache of the git worktree/index mismatch (issue #155). The
     // mismatch is a fixed property of (where the request came from → which
-    // .codegraph/ it resolves to), so the up-to-two `git rev-parse` spawns run
+    // .lattice/sensor/ it resolves to), so the up-to-two `git rev-parse` spawns run
     // once and every later tool call reuses the result — never shelling out to
     // git on the hot path. `undefined` = not computed yet; `null` = no mismatch.
     worktreeMismatchCache = new Map();
@@ -719,12 +715,12 @@ class ToolHandler {
     // ADR 0049 Decision 5②: the reason the DEFAULT project's index failed to
     // open (DB open failure, schema mismatch, integrity error, lock
     // contention) — set by the engine's init path, distinct from "no
-    // .codegraph/ found" (which leaves this null and falls through to
+    // .lattice/sensor/ found" (which leaves this null and falls through to
     // NotIndexedError's success-shaped guidance). Cleared on a successful
-    // {@link setDefaultCodeGraph}.
+    // {@link setDefaultLatticeSensor}.
     openFailure = null;
     // ADR 0049 Decision 5④: this session's execution mode, reported by
-    // codegraph_status as a machine-readable field. Defaults to a direct/
+    // lattice_sensor_status as a machine-readable field. Defaults to a direct/
     // no-daemon placeholder — every real caller (MCPServer.startDirect, the
     // shared Daemon, the local-handshake proxy's fallback engine) calls
     // {@link setExecutionMode} before any tool call can reach a live engine.
@@ -742,20 +738,20 @@ class ToolHandler {
         this.queryPool = pool;
     }
     /**
-     * Update the default CodeGraph instance (e.g. after lazy initialization).
+     * Update the default LatticeSensor instance (e.g. after lazy initialization).
      * A successful open supersedes any previously recorded open failure.
      */
-    setDefaultCodeGraph(cg) {
+    setDefaultLatticeSensor(cg) {
         this.cg = cg;
         this.openFailure = null;
     }
     /**
      * ADR 0049 Decision 5②: record that the DEFAULT project's index failed to
-     * open for a reason OTHER than "no .codegraph/ found" — the engine calls
-     * this from its init catch block. `getCodeGraph()` throws it (fail closed)
+     * open for a reason OTHER than "no .lattice/sensor/ found" — the engine calls
+     * this from its init catch block. `getLatticeSensor()` throws it (fail closed)
      * instead of the NotIndexedError guidance the next time a tool call needs
      * the default project, so the failure surfaces as `isError: true` rather
-     * than being silently absorbed into "just run codegraph init" prose.
+     * than being silently absorbed into "just run lattice sensor init . --json" prose.
      */
     setOpenFailure(err) {
         this.openFailure = err;
@@ -764,7 +760,7 @@ class ToolHandler {
      * ADR 0049 Decision 5④: record this session's execution mode
      * (`daemon`/`direct`) and the typed reason direct mode was chosen (or
      * `'daemon'` when routed through the shared daemon). Surfaced verbatim by
-     * `codegraph_status`.
+     * `lattice_sensor_status`.
      */
     setExecutionMode(mode, reason) {
         this.executionMode = { mode, reason };
@@ -813,8 +809,8 @@ class ToolHandler {
                 timedOut,
             ]);
             if (outcome === 'timeout') {
-                process.stderr.write(`[CodeGraph MCP] Catch-up reconcile still running after ${timeoutMs}ms; serving this tool call now and finishing the reconcile in the background (#905). ` +
-                    `Set CODEGRAPH_CATCHUP_GATE_TIMEOUT_MS=0 to always wait for it.\n`);
+                process.stderr.write(`[LatticeSensor MCP] Catch-up reconcile still running after ${timeoutMs}ms; serving this tool call now and finishing the reconcile in the background (#905). ` +
+                    `Set LATTICE_SENSOR_CATCHUP_GATE_TIMEOUT_MS=0 to always wait for it.\n`);
             }
         }
         finally {
@@ -830,46 +826,46 @@ class ToolHandler {
         this.defaultProjectHint = searchedPath;
     }
     /**
-     * Whether a default CodeGraph instance is available
+     * Whether a default LatticeSensor instance is available
      */
-    hasDefaultCodeGraph() {
+    hasDefaultLatticeSensor() {
         return this.cg !== null;
     }
     /**
-     * Optional allowlist of exposed tools, parsed from the CODEGRAPH_MCP_TOOLS
+     * Optional allowlist of exposed tools, parsed from the LATTICE_SENSOR_MCP_TOOLS
      * env var (comma-separated short names, e.g. "trace,search,node,context").
-     * Unset/empty → every tool is exposed. Lets an operator (or an A/B harness)
+     * Unset/empty → the contracted eight-tool surface. Lets an operator (or an A/B harness)
      * trim the tool surface without rebuilding the client config; the ablated
      * tool is then truly absent from ListTools rather than merely denied on call.
-     * Matching is on the short form, so "node" and "codegraph_node" both work.
+     * Matching is on the short form, so "node" and "lattice_sensor_node" both work.
      */
     toolAllowlist() {
-        const raw = process.env.CODEGRAPH_MCP_TOOLS;
+        const raw = process.env.LATTICE_SENSOR_MCP_TOOLS;
         if (!raw || !raw.trim())
             return null;
-        const short = (s) => s.trim().replace(/^codegraph_/, '');
+        const short = (s) => s.trim().replace(/^lattice_sensor_/, '');
         const set = new Set(raw.split(',').map(short).filter(Boolean));
         return set.size ? set : null;
     }
-    /** Whether a tool name passes the CODEGRAPH_MCP_TOOLS allowlist (if any). */
+    /** Whether a tool name passes the LATTICE_SENSOR_MCP_TOOLS allowlist (if any). */
     isToolAllowed(name) {
         const allow = this.toolAllowlist();
-        return !allow || allow.has(name.replace(/^codegraph_/, ''));
+        return !allow || allow.has(name.replace(/^lattice_sensor_/, ''));
     }
     /**
      * Get tool definitions with dynamic descriptions based on project size.
-     * The codegraph_explore tool description includes a budget recommendation
-     * scaled to the number of indexed files. Honors the CODEGRAPH_MCP_TOOLS
+     * The lattice_sensor_explore tool description includes a budget recommendation
+     * scaled to the number of indexed files. Honors the LATTICE_SENSOR_MCP_TOOLS
      * allowlist so a trimmed surface is reflected in ListTools.
      */
     getTools() {
         const allow = this.toolAllowlist();
-        // No explicit allowlist → the default 4-tool surface (see
+        // No explicit allowlist → the contracted eight-tool surface (see
         // DEFAULT_MCP_TOOLS for the evidence). An allowlist replaces the
         // default entirely, so any defined tool can be re-enabled.
         let visible = allow
-            ? exports.tools.filter(t => allow.has(t.name.replace(/^codegraph_/, '')))
-            : exports.tools.filter(t => DEFAULT_MCP_TOOLS.has(t.name.replace(/^codegraph_/, '')));
+            ? exports.tools.filter(t => allow.has(t.name.replace(/^lattice_sensor_/, '')))
+            : exports.tools.filter(t => DEFAULT_MCP_TOOLS.has(t.name.replace(/^lattice_sensor_/, '')));
         // No default project loaded → no-root-index case (#993): a gateway server
         // started outside any repo, or a monorepo root whose indexes live in
         // sub-projects. With nothing to fall back to, EVERY call needs an explicit
@@ -885,40 +881,8 @@ class ToolHandler {
         try {
             const stats = this.cg.getStats();
             const budget = getExploreBudget(stats.fileCount);
-            // Tiny-repo tool gating: on projects under TINY_REPO_FILE_THRESHOLD
-            // files, only expose the core trio (search, node, explore) — one
-            // below even the 4-tool default: at this scale callers, too, reduces
-            // to one grep. (Historical note: the audit below ran when context and
-            // trace still existed; its "5 core tools" are today's trio.)
-            //
-            // n=2 audits ruled out cutting below 5 tools:
-            // - 3-tool gate (search + context + trace): cost regressed on
-            //   cobra/ky/sinatra. The agent fell back to raw Reads to cover
-            //   what codegraph_node + codegraph_explore would have answered.
-            // - 1-tool gate (search only): catastrophic regression — express
-            //   went from -43% WIN to +107% LOSS. With only search, the agent
-            //   can't navigate the call graph structurally and reads everything.
-            //
-            // 5 is the empirical lower bound. Tools beyond search/context/
-            // node/explore/trace pay overhead that the agent doesn't recoup
-            // on tiny-repo flow questions.
-            // ITER4: raise threshold 150 → 500 so single-file frameworks
-            // (sinatra at 159, slim_framework around 200) also get the
-            // 5-tool surface. The empirical 5-tool floor was set on <150
-            // probes; iter3 measurement showed sinatra is structurally the
-            // SAME problem as cobra (single-file WITHOUT-arm Read wins),
-            // so it deserves the same gating.
-            const TINY_REPO_FILE_THRESHOLD = 500;
-            const TINY_REPO_CORE_TOOLS = new Set([
-                'codegraph_explore',
-                'codegraph_search',
-                'codegraph_node',
-            ]);
-            if (stats.fileCount < TINY_REPO_FILE_THRESHOLD) {
-                visible = visible.filter(t => TINY_REPO_CORE_TOOLS.has(t.name));
-            }
             return visible.map(tool => {
-                if (tool.name === 'codegraph_explore') {
+                if (tool.name === 'lattice_sensor_explore') {
                     return {
                         ...tool,
                         description: `${tool.description} Budget: make at most ${budget} calls for this project (${stats.fileCount.toLocaleString()} files indexed).`,
@@ -932,15 +896,15 @@ class ToolHandler {
         }
     }
     /**
-     * Get CodeGraph instance for a project
+     * Get LatticeSensor instance for a project
      *
-     * If projectPath is provided, opens that project's CodeGraph (cached).
-     * Otherwise returns the default CodeGraph instance.
+     * If projectPath is provided, opens that project's LatticeSensor (cached).
+     * Otherwise returns the default LatticeSensor instance.
      *
-     * Walks up parent directories to find the nearest .codegraph/ folder,
+     * Walks up parent directories to find the nearest .lattice/sensor/ folder,
      * similar to how git finds .git/ directories.
      */
-    getCodeGraph(projectPath) {
+    getLatticeSensor(projectPath) {
         if (!projectPath) {
             if (!this.cg) {
                 // ADR 0049 Decision 5②: a recorded open failure (DB open error,
@@ -950,31 +914,31 @@ class ToolHandler {
                 // NotIndexedError guidance below, which would misleadingly read as
                 // "this project just isn't indexed yet".
                 if (this.openFailure) {
-                    throw new IndexOpenError(`The default project's CodeGraph index failed to open: ${this.openFailure.message}\n` +
+                    throw new IndexOpenError(`The default project's LatticeSensor index failed to open: ${this.openFailure.message}\n` +
                         'This is a genuine malfunction (corrupt/locked database, schema mismatch, or ' +
                         'similar) — NOT a missing index. Retry the call once; if it persists, the index ' +
-                        'may need to be rebuilt (`codegraph init` after removing `.codegraph/`) or a ' +
+                        'may need to be rebuilt (`lattice sensor init . --json` after removing `.lattice/sensor/`) or a ' +
                         'stale lock cleared.');
                 }
                 const searched = this.defaultProjectHint ?? process.cwd();
-                throw new NotIndexedError('No CodeGraph project is loaded for this session.\n' +
-                    `Searched for a .codegraph/ directory starting from: ${searched}\n` +
+                throw new NotIndexedError('No LatticeSensor project is loaded for this session.\n' +
+                    `Searched for a .lattice/sensor/ directory starting from: ${searched}\n` +
                     'Either the server root has no index of its own (e.g. a monorepo where only ' +
                     "sub-projects are indexed), or the MCP client launched the server outside your " +
                     'project without reporting the workspace root. Either way, target the project ' +
                     'explicitly:\n' +
                     '  • Pass projectPath to the tool call, e.g. projectPath: "/absolute/path/to/your/project" ' +
-                    '(any project that has a .codegraph/ — including a sub-project of a monorepo)\n' +
+                    '(any project that has a .lattice/sensor/ — including a sub-project of a monorepo)\n' +
                     '  • Or add --path to the server\'s MCP config args: ["serve", "--mcp", "--path", "/absolute/path/to/your/project"]\n' +
                     'If a project simply has no index, use your built-in tools (Read/Grep/Glob) for THAT ' +
-                    "project (the user can run 'codegraph init' there to enable it) — you can still query " +
+                    "project (the user can run 'lattice sensor init . --json' there to enable it) — you can still query " +
                     'other indexed projects by projectPath in the same session.');
             }
             return this.freshen(this.cg);
         }
         // Reject sensitive system directories before opening. Only validate a
         // path that actually exists — a nested or not-yet-created sub-path of a
-        // real project must still be allowed to resolve UP to its .codegraph/
+        // real project must still be allowed to resolve UP to its .lattice/sensor/
         // root below (issue #238), so we don't run the existence-checking
         // validator on paths that are meant to walk up.
         if ((0, fs_1.existsSync)(projectPath)) {
@@ -983,22 +947,22 @@ class ToolHandler {
                 throw new PathRefusalError(pathError);
             }
         }
-        // Always RE-RESOLVE the nearest .codegraph/ from the input path. The walk
+        // Always RE-RESOLVE the nearest .lattice/sensor/ from the input path. The walk
         // is cheap (a few existsSync up the tree) and is the only thing that
         // notices a path whose index root CHANGED since it was first seen — most
-        // importantly a git worktree that gained its own .codegraph/ after the
+        // importantly a git worktree that gained its own .lattice/sensor/ after the
         // (long-lived) server first resolved it up to the parent checkout. We used
         // to short-circuit on a `projectCache[projectPath]` entry before resolving,
         // which pinned that first resolution for the server's whole lifetime, so a
         // worktree kept being served the parent checkout's index until restart
         // (#926). The DB connection itself is still cached (by resolved root,
         // below), so re-resolving costs only the stat walk, never a reopen.
-        const resolvedRoot = (0, directory_1.findNearestCodeGraphRoot)(projectPath);
+        const resolvedRoot = (0, directory_1.findNearestLatticeSensorRoot)(projectPath);
         if (!resolvedRoot) {
-            throw new NotIndexedError(`The project at ${projectPath} isn't indexed with codegraph (no .codegraph/ directory found ` +
-                'walking up from it), so codegraph cannot query it. Use your built-in tools (Read/Grep/Glob) ' +
-                "for that codebase instead, and don't call codegraph for it again this session. " +
-                "Indexing is the user's decision — they can run 'codegraph init' in that project to enable it.");
+            throw new NotIndexedError(`The project at ${projectPath} isn't indexed with lattice sensor (no .lattice/sensor/ directory found ` +
+                'walking up from it), so lattice sensor cannot query it. Use your built-in tools (Read/Grep/Glob) ' +
+                "for that codebase instead, and don't call lattice sensor for it again this session. " +
+                "Indexing is the user's decision — they can run 'lattice sensor init . --json' in that project to enable it.");
         }
         // If the path resolves to the default project, reuse the already-open
         // default instance rather than opening a SECOND connection to the same DB.
@@ -1016,13 +980,13 @@ class ToolHandler {
         const cached = this.projectCache.get(resolvedRoot);
         if (cached)
             return this.freshen(cached);
-        const cg = loadCodeGraph().openSync(resolvedRoot);
+        const cg = loadLatticeSensor().openSync(resolvedRoot);
         this.projectCache.set(resolvedRoot, cg);
         return cg;
     }
     /**
-     * Heal a long-lived connection whose `.codegraph/` was removed and recreated
-     * at the same path (a worktree recreated, or `rm -rf .codegraph` + re-init)
+     * Heal a long-lived connection whose `.lattice/sensor/` was removed and recreated
+     * at the same path (a worktree recreated, or `rm -rf .lattice/sensor` + re-init)
      * before handing it to a tool. Otherwise the daemon keeps serving the
      * pre-removal snapshot from its now-unlinked file handle until restart — and
      * because the daemon registry is keyed by path, a same-path recreate routes
@@ -1033,7 +997,7 @@ class ToolHandler {
     freshen(cg) {
         try {
             if (cg.reopenIfReplaced()) {
-                process.stderr.write('[CodeGraph MCP] The index was replaced on disk (e.g. a git worktree ' +
+                process.stderr.write('[LatticeSensor MCP] The index was replaced on disk (e.g. a git worktree ' +
                     'recreated at the same path); reopened the live database in place.\n');
             }
         }
@@ -1099,7 +1063,7 @@ class ToolHandler {
         const startPath = projectPath ?? this.defaultProjectHint ?? process.cwd();
         // The verdict depends on BOTH the start path AND the index root it resolves
         // to, so the cache must be keyed on the pair. Resolve the index root first
-        // (cheap — getCodeGraph re-walks to the nearest .codegraph/, no git), then
+        // (cheap — getLatticeSensor re-walks to the nearest .lattice/sensor/, no git), then
         // key on `(startPath, indexRoot)`. The moment that root changes — most
         // importantly when a git worktree gains its own index and the walk-up stops
         // there instead of at the parent checkout — the key changes and the verdict
@@ -1108,7 +1072,7 @@ class ToolHandler {
         // that first verdict until restart (#926).
         let indexRoot;
         try {
-            indexRoot = this.getCodeGraph(projectPath).getProjectRoot();
+            indexRoot = this.getLatticeSensor(projectPath).getProjectRoot();
         }
         catch {
             // No resolvable project (or any other resolution error) → nothing to warn.
@@ -1127,7 +1091,7 @@ class ToolHandler {
      * notice when the resolved index belongs to a different git working tree than
      * the caller's (issue #155). Without this, an agent in a nested worktree
      * silently trusts main-branch results. No-op on error results and when there
-     * is no mismatch. `codegraph_status` is excluded — it embeds its own verbose
+     * is no mismatch. `lattice_sensor_status` is excluded — it embeds its own verbose
      * warning — so it stays out of this path.
      */
     withWorktreeNotice(result, projectPath) {
@@ -1161,12 +1125,12 @@ class ToolHandler {
             return result;
         let cg;
         try {
-            cg = this.getCodeGraph(projectPath);
+            cg = this.getLatticeSensor(projectPath);
         }
         catch {
             return result; // no default project — leave as is
         }
-        // Cross-project `projectPath` calls open a cached CodeGraph WITHOUT a
+        // Cross-project `projectPath` calls open a cached LatticeSensor WITHOUT a
         // watcher (watchers are only attached to the default session project).
         // When the cross-project path happens to be the same project as the
         // default cg, the cached instance is the wrong one — its pendingFiles is
@@ -1188,7 +1152,7 @@ class ToolHandler {
         // fire — but the index is now FROZEN and silently drifting stale. Surface
         // one global notice instead, so the agent Reads for current content rather
         // than trusting a response off a no-longer-updating index. (Cross-project
-        // calls open a watcher-less CodeGraph, so this is false there — correct: we
+        // calls open a watcher-less LatticeSensor, so this is false there — correct: we
         // only know degraded state for the default session project.)
         let degraded = false;
         try {
@@ -1211,7 +1175,7 @@ class ToolHandler {
             const composed = `${formatDegradedBanner(reason)}\n\n${head.text}`;
             return { ...result, content: [{ type: 'text', text: composed }, ...tail] };
         }
-        // Defensive: some test fakes inject a partial CodeGraph stub without the
+        // Defensive: some test fakes inject a partial LatticeSensor stub without the
         // newer pending-files API. Treat missing/throwing as "no pending files."
         let pending = [];
         try {
@@ -1230,7 +1194,7 @@ class ToolHandler {
         const elsewhere = [];
         for (const p of pending) {
             // Substring match against the project-relative POSIX path — that's
-            // exactly the format both the watcher and every codegraph response
+            // exactly the format both the watcher and every lattice sensor response
             // emit, so a plain includes() is sufficient and avoids regex pitfalls.
             if (text.includes(p.path))
                 inResponse.push(p);
@@ -1268,10 +1232,10 @@ class ToolHandler {
                 this.catchUpGate = null;
                 await this.awaitCatchUpGate(gate);
             }
-            // Honor the optional tool allowlist (CODEGRAPH_MCP_TOOLS): a trimmed
+            // Honor the optional tool allowlist (LATTICE_SENSOR_MCP_TOOLS): a trimmed
             // surface rejects ablated tools defensively even if a client cached them.
             if (!this.isToolAllowed(toolName)) {
-                return this.errorResult(`Tool ${toolName} is disabled via CODEGRAPH_MCP_TOOLS`);
+                return this.errorResult(`Tool ${toolName} is disabled via LATTICE_SENSOR_MCP_TOOLS`);
             }
             // Cross-cutting input validation. All tools accept an optional
             // `projectPath` and most accept either `query`, `task`, or
@@ -1281,7 +1245,7 @@ class ToolHandler {
             if (typeof pathCheck === 'object' && pathCheck !== undefined) {
                 return pathCheck;
             }
-            // The `path` and `pattern` properties used by codegraph_files are
+            // The `path` and `pattern` properties used by lattice_sensor_files are
             // also path-shaped — apply the same cap.
             if (args.path !== undefined) {
                 const check = this.validateOptionalPath(args.path, 'path');
@@ -1293,12 +1257,12 @@ class ToolHandler {
                 if (typeof check === 'object' && check !== undefined)
                     return check;
             }
-            // codegraph_status reports watcher state (pending files, degraded mode,
+            // lattice_sensor_status reports watcher state (pending files, degraded mode,
             // worktree warning) and embeds its own sections — it must run on the MAIN
             // thread against the watched default instance, so it is NEVER off-loaded to
             // a worker (whose read connection has no watcher). It also skips the
             // auto-banner wrapper to avoid duplicating its own pending-files section.
-            if (toolName === 'codegraph_status') {
+            if (toolName === 'lattice_sensor_status') {
                 return await this.handleStatus(args);
             }
             // Read tools: off-load the CPU-heavy dispatch to the worker pool when one
@@ -1333,8 +1297,8 @@ class ToolHandler {
                 return this.errorResult(err.message);
             }
             return this.errorResult(`Tool execution failed: ${err instanceof Error ? err.message : String(err)}. ` +
-                'This is an internal codegraph error — retry the call once; if it persists, ' +
-                'continue without codegraph for this task.');
+                'This is an internal lattice sensor error — retry the call once; if it persists, ' +
+                'continue without lattice sensor for this task.');
         }
     }
     /**
@@ -1362,36 +1326,36 @@ class ToolHandler {
                 return this.errorResult(err.message);
             }
             return this.errorResult(`Tool execution failed: ${err instanceof Error ? err.message : String(err)}. ` +
-                'This is an internal codegraph error — retry the call once; if it persists, ' +
-                'continue without codegraph for this task.');
+                'This is an internal lattice sensor error — retry the call once; if it persists, ' +
+                'continue without lattice sensor for this task.');
         }
     }
     /**
      * Pure dispatch over the read tools — the switch, with no gate, no notices, no
-     * allowlist/validation (the caller owns those). `codegraph_status` is handled
+     * allowlist/validation (the caller owns those). `lattice_sensor_status` is handled
      * on the main thread in {@link execute} and never reaches here. May throw
      * NotIndexed/PathRefusal, which {@link executeReadTool} classifies.
      */
     async dispatchTool(toolName, args) {
         switch (toolName) {
-            case 'codegraph_search': return await this.handleSearch(args);
-            case 'codegraph_callers': return await this.handleCallers(args);
-            case 'codegraph_callees': return await this.handleCallees(args);
-            case 'codegraph_impact': return await this.handleImpact(args);
-            case 'codegraph_explore': return await this.handleExplore(args);
-            case 'codegraph_node': return await this.handleNode(args);
-            case 'codegraph_files': return await this.handleFiles(args);
+            case 'lattice_sensor_search': return await this.handleSearch(args);
+            case 'lattice_sensor_callers': return await this.handleCallers(args);
+            case 'lattice_sensor_callees': return await this.handleCallees(args);
+            case 'lattice_sensor_impact': return await this.handleImpact(args);
+            case 'lattice_sensor_explore': return await this.handleExplore(args);
+            case 'lattice_sensor_node': return await this.handleNode(args);
+            case 'lattice_sensor_files': return await this.handleFiles(args);
             default: return this.errorResult(`Unknown tool: ${toolName}`);
         }
     }
     /**
-     * Handle codegraph_search
+     * Handle lattice_sensor_search
      */
     async handleSearch(args) {
         const query = this.validateString(args.query, 'query');
         if (typeof query !== 'string')
             return query;
-        const cg = this.getCodeGraph(args.projectPath);
+        const cg = this.getLatticeSensor(args.projectPath);
         const rawKind = args.kind;
         // The schema enum says 'type' (what agents naturally reach for); the
         // NodeKind is 'type_alias'. Without the mapping, kind: "type" silently
@@ -1455,13 +1419,13 @@ class ToolHandler {
         return `**${head.qualifiedName}** (${head.kind}) — ${head.filePath}${line}`;
     }
     /**
-     * Handle codegraph_callers
+     * Handle lattice_sensor_callers
      */
     async handleCallers(args) {
         const symbol = this.validateString(args.symbol, 'symbol');
         if (typeof symbol !== 'string')
             return symbol;
-        const cg = this.getCodeGraph(args.projectPath);
+        const cg = this.getLatticeSensor(args.projectPath);
         const limit = (0, utils_1.clamp)(args.limit || 20, 1, 100);
         const fileFilter = typeof args.file === 'string' ? args.file : undefined;
         const allMatches = this.findAllSymbols(cg, symbol);
@@ -1523,13 +1487,13 @@ class ToolHandler {
         return this.textResult(this.truncateOutput(lines.join('\n') + filterNote));
     }
     /**
-     * Handle codegraph_callees
+     * Handle lattice_sensor_callees
      */
     async handleCallees(args) {
         const symbol = this.validateString(args.symbol, 'symbol');
         if (typeof symbol !== 'string')
             return symbol;
-        const cg = this.getCodeGraph(args.projectPath);
+        const cg = this.getLatticeSensor(args.projectPath);
         const limit = (0, utils_1.clamp)(args.limit || 20, 1, 100);
         const fileFilter = typeof args.file === 'string' ? args.file : undefined;
         const allMatches = this.findAllSymbols(cg, symbol);
@@ -1588,13 +1552,13 @@ class ToolHandler {
         return this.textResult(this.truncateOutput(lines.join('\n') + filterNote));
     }
     /**
-     * Handle codegraph_impact
+     * Handle lattice_sensor_impact
      */
     async handleImpact(args) {
         const symbol = this.validateString(args.symbol, 'symbol');
         if (typeof symbol !== 'string')
             return symbol;
-        const cg = this.getCodeGraph(args.projectPath);
+        const cg = this.getLatticeSensor(args.projectPath);
         const depth = (0, utils_1.clamp)(args.depth || 2, 1, 10);
         const fileFilter = typeof args.file === 'string' ? args.file : undefined;
         const allMatches = this.findAllSymbols(cg, symbol);
@@ -1735,7 +1699,7 @@ class ToolHandler {
         return null;
     }
     /**
-     * Flow-from-named-symbols: an agent's codegraph_explore query is a bag of
+     * Flow-from-named-symbols: an agent's lattice_sensor_explore query is a bag of
      * symbol names that usually spans the flow it's investigating (e.g.
      * "PmsProductController getList PmsProductService list PmsProductServiceImpl").
      * Surface the longest call chain AMONG those named symbols — scoped to what the
@@ -2115,7 +2079,7 @@ class ToolHandler {
             '',
             ...notes,
             '',
-            '> These sites choose their call target at runtime (registry / bus / reflection) — the site shown IS where the flow continues. To follow it, run codegraph_explore or codegraph_node on a candidate; source for the sites above is included below.',
+            '> These sites choose their call target at runtime (registry / bus / reflection) — the site shown IS where the flow continues. To follow it, run lattice_sensor_explore or lattice_sensor_node on a candidate; source for the sites above is included below.',
             '',
         ].join('\n');
     }
@@ -2129,7 +2093,7 @@ class ToolHandler {
      * the concrete target is chosen at runtime from N implementations, so no single
      * static edge is "the answer" — the implementations ARE the continuations. We
      * announce the supertype, its TRUE implementer count, and a few concrete targets,
-     * then steer to codegraph_explore. Graph-only, query-time, zero mutation; the
+     * then steer to lattice_sensor_explore. Graph-only, query-time, zero mutation; the
      * caller fires it ONLY for an UNCOVERED named token, so a connected flow is silent.
      *
      * Robust to FTS sampling bias: the same-name family is a capped FTS sample that
@@ -2222,7 +2186,7 @@ class ToolHandler {
             '',
             ...notes,
             '',
-            '> The method above is dispatched at runtime to one of the listed implementations (a registry / plugin / strategy interface) — there is no single static caller→callee edge; the implementations ARE the continuations. To follow one, run codegraph_explore on a listed target.',
+            '> The method above is dispatched at runtime to one of the listed implementations (a registry / plugin / strategy interface) — there is no single static caller→callee edge; the implementations ARE the continuations. To follow one, run lattice_sensor_explore on a listed target.',
             '',
         ].join('\n');
     }
@@ -2375,7 +2339,7 @@ class ToolHandler {
      * PageRank) from the query's matched SEED nodes over the call/reference graph.
      *
      * This is the ranking signal text search (FTS/bm25) CANNOT provide, and it's
-     * codegraph's home turf: relevance by STRUCTURE, not words. A file whose
+     * lattice sensor's home turf: relevance by STRUCTURE, not words. A file whose
      * symbols are call-connected to the matched cluster accrues walk mass and
      * ranks high; a lone TEXT match — e.g. `LensSwitcher.swift` matched the word
      * "switch" from `switchOrganization`, but calls none of `setUser`/`fetchUser`
@@ -2453,11 +2417,11 @@ class ToolHandler {
         return out;
     }
     /**
-     * Handle codegraph_explore — deep exploration in a single call
+     * Handle lattice_sensor_explore — deep exploration in a single call
      *
      * Strategy: find relevant symbols via graph traversal, group by file,
      * then read contiguous file sections covering all symbols per file.
-     * This replaces multiple codegraph_node + Read calls.
+     * This replaces multiple lattice_sensor_node + Read calls.
      *
      * Output size is adaptive to project file count via
      * `getExploreOutputBudget` — see #185 for why a fixed 35k cap was a
@@ -2470,7 +2434,7 @@ class ToolHandler {
         // One normalization point so the flow-builder, relevance search, and
         // ranking all see the same canonical spelling (Erlang `mod:fn/arity`).
         const query = normalizeQuerySpelling(rawQuery);
-        const cg = this.getCodeGraph(args.projectPath);
+        const cg = this.getLatticeSensor(args.projectPath);
         const projectRoot = cg.getProjectRoot();
         // Resolve adaptive output budget from project size. Falls back to the
         // largest-tier defaults if stats aren't available, which preserves
@@ -2615,7 +2579,7 @@ class ToolHandler {
                 // 50+-overload name (tokio `poll`) ranks the wanted def (`Harness::poll`)
                 // below the FTS cut, so findAllSymbols would never see it and the
                 // type-token bias below couldn't pick the harness.rs one. (Same fix as
-                // codegraph_node's findSymbolMatches.) Qualified tokens keep findAllSymbols.
+                // lattice_sensor_node's findSymbolMatches.) Qualified tokens keep findAllSymbols.
                 const isQual = /[.\/]|::/.test(t);
                 const raw = isQual ? this.findAllSymbols(cg, t).nodes : cg.getNodesByName(t);
                 let cands = raw
@@ -2661,7 +2625,7 @@ class ToolHandler {
                 // only: the overloads whose file/class the query ALSO names (the agent
                 // told us which one it wants — DataRequest's, not Validation.swift's),
                 // capped; else fall back to the single most-substantive def. This is the
-                // explore-side mirror of codegraph_node's overload disambiguation.
+                // explore-side mirror of lattice_sensor_node's overload disambiguation.
                 let picks;
                 let tierPicks; // subset that earns the named-first tier (#1064)
                 if (cands.length <= 3) {
@@ -2949,9 +2913,9 @@ class ToolHandler {
         // neither entry nor central (a type/util file that matches "element"+x but isn't
         // the flow) is NOT promoted, so it can't displace the graph-central answer file
         // (hits=1) the way a blunt hits-only tier would. Single-layer repos with one
-        // cluster are unaffected (no competing mass). Set CODEGRAPH_RANK_NO_MULTITERM=1
+        // cluster are unaffected (no competing mass). Set LATTICE_SENSOR_RANK_NO_MULTITERM=1
         // to disable.
-        const MULTITERM_OFF = process.env.CODEGRAPH_RANK_NO_MULTITERM === '1';
+        const MULTITERM_OFF = process.env.LATTICE_SENSOR_RANK_NO_MULTITERM === '1';
         const isCorroborated = (fp) => !MULTITERM_OFF &&
             (fileTermHits.get(fp) ?? 0) >= 2 &&
             (entryFiles.has(fp) || centralFiles.has(fp));
@@ -3139,7 +3103,7 @@ class ToolHandler {
             }
             const fileLines = fileContent.split('\n');
             const lang = group.nodes[0]?.language || '';
-            // Adaptive sizing (CODEGRAPH_ADAPTIVE_EXPLORE, default on): collapse a file
+            // Adaptive sizing (LATTICE_SENSOR_ADAPTIVE_EXPLORE, default on): collapse a file
             // to a per-symbol view when it's a redundant member of a polymorphic family.
             // Engages iff ALL hold:
             //   1. a flow spine exists,
@@ -3254,15 +3218,15 @@ class ToolHandler {
                 if (skel.length > 0) {
                     const names = [...new Set(group.nodes.filter(n => n.kind !== 'import' && n.kind !== 'export').map(n => n.name))]
                         .slice(0, budget.maxSymbolsInFileHeader).join(', ');
-                    // Steer the agent to codegraph_explore for an elided body — NEVER to
+                    // Steer the agent to lattice_sensor_explore for an elided body — NEVER to
                     // Read. The old "Read for more" / "Read for a full body" tags invited
                     // a Read of the very file just skeletonized; on a central, wanted file
                     // (Session.swift, DataRequest.swift) that fired an over-investigation
                     // spiral (the agent Read the skeletonized file, then kept digging).
                     // CLAUDE.md: explore output must never tell the agent to Read.
                     const tag = bodyIds.size > 0
-                        ? 'focused (the methods you named in full, the rest as signatures — codegraph_explore a signature by name for its body; do NOT Read)'
-                        : 'skeleton (signatures only — codegraph_explore a name for its full body; do NOT Read)';
+                        ? 'focused (the methods you named in full, the rest as signatures — lattice_sensor_explore a signature by name for its body; do NOT Read)'
+                        : 'skeleton (signatures only — lattice_sensor_explore a name for its full body; do NOT Read)';
                     lines.push(fileSectionHeader(filePath, `${names} · ${tag}`), '', '```' + lang, skel.join('\n'), '```', '');
                     totalChars += skel.join('\n').length + 120;
                     renderedFilePaths.push(filePath);
@@ -3637,11 +3601,11 @@ class ToolHandler {
         if (budget.includeCompletenessSignal) {
             lines.push('');
             lines.push('---');
-            lines.push(`> **Complete source for ${filesIncluded} files is included above — do NOT re-read them.** If your question also needs files/symbols listed under "Not shown above" (or any area this call didn't cover), make ANOTHER codegraph_explore targeting those names — it returns the same source with line numbers and is cheaper and more complete than reading. Reserve Read for a single specific line range explore can't surface.`);
+            lines.push(`> **Complete source for ${filesIncluded} files is included above — do NOT re-read them.** If your question also needs files/symbols listed under "Not shown above" (or any area this call didn't cover), make ANOTHER lattice_sensor_explore targeting those names — it returns the same source with line numbers and is cheaper and more complete than reading. Reserve Read for a single specific line range explore can't surface.`);
         }
         else if (anyFileTrimmed) {
             lines.push('');
-            lines.push(`> Some file sections were trimmed for size. For a specific symbol you still need, run another \`codegraph_explore\` (or \`codegraph_node\`) with its exact name — line-numbered source, cheaper and more complete than Read.`);
+            lines.push(`> Some file sections were trimmed for size. For a specific symbol you still need, run another \`lattice_sensor_explore\` (or \`lattice_sensor_node\`) with its exact name — line-numbered source, cheaper and more complete than Read.`);
         }
         // Add explore budget note based on project size
         if (budget.includeBudgetNote) {
@@ -3676,7 +3640,7 @@ class ToolHandler {
             const lastSection = cut.lastIndexOf('\n' + FILE_SECTION_PREFIX);
             const boundary = lastSection > hardCeiling * 0.5 ? lastSection : cut.lastIndexOf('\n');
             const safe = boundary > 0 ? cut.slice(0, boundary) : cut;
-            finalText = safe + '\n\n... (output truncated to budget; the source above is complete and verbatim — treat it as already Read. For any area not covered, run another codegraph_explore with the specific names — do NOT Read these files.)';
+            finalText = safe + '\n\n... (output truncated to budget; the source above is complete and verbatim — treat it as already Read. For any area not covered, run another lattice_sensor_explore with the specific names — do NOT Read these files.)';
         }
         else {
             finalText = output;
@@ -3702,10 +3666,10 @@ class ToolHandler {
         return this.textResult(finalText);
     }
     /**
-     * Handle codegraph_node
+     * Handle lattice_sensor_node
      */
     async handleNode(args) {
-        const cg = this.getCodeGraph(args.projectPath);
+        const cg = this.getLatticeSensor(args.projectPath);
         // Default to false to minimize context usage
         const includeCode = args.includeCode === true;
         const fileHint = typeof args.file === 'string' && args.file.trim() ? args.file.trim() : undefined;
@@ -3761,7 +3725,7 @@ class ToolHandler {
         // different types (Alamofire `didCompleteTask`/`task`/`validate`, gin
         // `reset`). Returning ONE forces the agent to guess, and when it guesses
         // wrong it READS the file to find the right overload — the dominant
-        // codegraph_node read cause on Swift/Go. So return them ALL: pack as many
+        // lattice_sensor_node read cause on Swift/Go. So return them ALL: pack as many
         // FULL bodies as fit a char budget (the agent gets the one it needs in this
         // one call, no follow-up parameter to learn), and list any remainder by
         // file:line so a large overload set can't overflow the per-tool cap.
@@ -3806,7 +3770,7 @@ class ToolHandler {
             out.push('', '**Other definitions**', ...shownList.map((n) => `- \`${n.name}\` (${n.kind}) — ${n.filePath}:${n.startLine}`));
             if (listed.length > LIST_CAP)
                 out.push(`- … +${listed.length - LIST_CAP} more`);
-            out.push('', `> Need one of these in full? Call codegraph_node again with \`file\` (e.g. \`"${listed[0].filePath.split('/').pop()}"\`) or \`line\` — do NOT Read it.`);
+            out.push('', `> Need one of these in full? Call lattice_sensor_node again with \`file\` (e.g. \`"${listed[0].filePath.split('/').pop()}"\`) or \`line\` — do NOT Read it.`);
         }
         return this.textResult(this.truncateOutput(out.join('\n')));
     }
@@ -3828,7 +3792,7 @@ class ToolHandler {
         const wantLower = normalize(fileArg).toLowerCase();
         const allFiles = cg.getFiles();
         if (allFiles.length === 0)
-            return this.textResult('No files indexed. Run `codegraph index` first.');
+            return this.textResult('No files indexed. Run `lattice sensor index` first.');
         let resolved = allFiles.find((f) => f.path.toLowerCase() === wantLower);
         let candidates = [];
         if (!resolved) {
@@ -3846,14 +3810,14 @@ class ToolHandler {
                 ...candidates.slice(0, 25).map((f) => `- ${f.path}`)].join('\n'));
         }
         if (!resolved) {
-            return this.textResult(`No indexed file matches "${fileArg}". Codegraph indexes source files; configs/docs it doesn't parse won't appear — Read those directly.`);
+            return this.textResult(`No indexed file matches "${fileArg}". Lattice sensor indexes source files; configs/docs it doesn't parse won't appear — Read those directly.`);
         }
         const filePath = resolved.path;
         const nodes = cg.getNodesInFile(filePath)
             .filter((n) => n.kind !== 'file' && n.kind !== 'import' && n.kind !== 'export')
             .sort((a, b) => a.startLine - b.startLine);
         const dependents = cg.getFileDependents(filePath);
-        // Compact, one-line blast radius (codegraph's value-add over a plain Read).
+        // Compact, one-line blast radius (lattice sensor's value-add over a plain Read).
         const depSummary = dependents.length
             ? `used by ${dependents.length} file${dependents.length === 1 ? '' : 's'}: ${dependents.slice(0, 8).join(', ')}${dependents.length > 8 ? `, +${dependents.length - 8} more` : ''}`
             : 'no other indexed file depends on it';
@@ -3884,7 +3848,7 @@ class ToolHandler {
             const out = [`**${filePath}** — configuration/data file, ${depSummary}`, ''];
             if (nodes.length)
                 out.push(...symbolMap('**Keys (values withheld for safety)**'));
-            out.push('', '> Values may be secrets, so codegraph indexes keys only. Read the file directly if you need a value.');
+            out.push('', '> Values may be secrets, so lattice sensor indexes keys only. Read the file directly if you need a value.');
             return this.textResult(this.truncateOutput(out.join('\n')));
         }
         // Read the current bytes from disk through the security chokepoint
@@ -3939,7 +3903,7 @@ class ToolHandler {
         const complete = offset === 1 && shownEnd >= total;
         const out = [header, '', ...numbered];
         if (!complete) {
-            out.push('', `(lines ${offset}–${shownEnd} of ${total} — pass \`offset\`/\`limit\` for another range, or \`codegraph_node <symbol>\` for one symbol in full)`);
+            out.push('', `(lines ${offset}–${shownEnd} of ${total} — pass \`offset\`/\`limit\` for another range, or \`lattice_sensor_node <symbol>\` for one symbol in full)`);
         }
         // Self-bounded to CHAR_BUDGET — do NOT route through truncateOutput (15k).
         return this.textResult(out.join('\n'));
@@ -3964,9 +3928,9 @@ class ToolHandler {
     }
     /**
      * Build the "trail" for a symbol: its direct callees (what it calls) and
-     * callers (what calls it), each with file:line — so codegraph_node doubles as
+     * callers (what calls it), each with file:line — so lattice_sensor_node doubles as
      * the structural Grep→Read→expand primitive: a spot PLUS where to go next.
-     * Capped to stay cheap. Walk the graph by calling codegraph_node on a trail
+     * Capped to stay cheap. Walk the graph by calling lattice_sensor_node on a trail
      * entry; no Read needed for covered hops. Empty edges on a non-leaf often mean
      * dynamic dispatch the static graph couldn't resolve — that absence is itself
      * a signal (read that one hop) rather than a dead end.
@@ -3993,7 +3957,7 @@ class ToolHandler {
         const callers = collect(cg.getCallers(node.id));
         if (callees.length === 0 && callers.length === 0)
             return '';
-        const lines = ['', '**Trail — codegraph_node any of these to follow it (no Read needed)**'];
+        const lines = ['', '**Trail — lattice_sensor_node any of these to follow it (no Read needed)**'];
         if (callees.length > 0) {
             lines.push(`**Calls →** ${callees.slice(0, TRAIL_CAP).map(fmt).join(', ')}${callees.length > TRAIL_CAP ? `, +${callees.length - TRAIL_CAP} more` : ''}`);
         }
@@ -4003,10 +3967,10 @@ class ToolHandler {
         return lines.join('\n');
     }
     /**
-     * Handle codegraph_status
+     * Handle lattice_sensor_status
      */
     async handleStatus(args) {
-        let cg = this.getCodeGraph(args.projectPath);
+        let cg = this.getLatticeSensor(args.projectPath);
         // Same trick as withStalenessNotice — when an explicit projectPath
         // resolves to the same project as the default session cg, prefer the
         // default so getPendingFiles() (only populated by the default's watcher)
@@ -4027,7 +3991,7 @@ class ToolHandler {
         // one-liner via withWorktreeNotice. Both share the cached detection.
         const mismatch = this.worktreeMismatchFor(args.projectPath);
         const lines = [
-            '**CodeGraph Status**',
+            '**Lattice Sensor Status**',
             '',
         ];
         if (mismatch) {
@@ -4040,7 +4004,7 @@ class ToolHandler {
         // as plain `key: value` lines (not buried in prose) so a caller can parse
         // them without depending on the surrounding Markdown.
         const executionMode = this.executionMode;
-        lines.push(`**Lattice sensor version:** ${version_1.CodeGraphPackageVersion}`, `mode: ${executionMode.mode}`, `reason: ${executionMode.reason}`, '', `**Files indexed:** ${stats.fileCount}`, `**Total nodes:** ${stats.nodeCount}`, `**Total edges:** ${stats.edgeCount}`, `**Database size:** ${(stats.dbSizeBytes / 1024 / 1024).toFixed(2)} MB`);
+        lines.push('provider: lattice', 'sensor_owner: lattice', `**Lattice sensor version:** ${version_1.LatticeSensorPackageVersion}`, `mode: ${executionMode.mode}`, `reason: ${executionMode.reason}`, '', `**Files indexed:** ${stats.fileCount}`, `**Total nodes:** ${stats.nodeCount}`, `**Total edges:** ${stats.edgeCount}`, `**Database size:** ${(stats.dbSizeBytes / 1024 / 1024).toFixed(2)} MB`);
         // Surface the active SQLite backend (node:sqlite, Node's built-in real
         // SQLite — full WAL + FTS5, no native build).
         lines.push(`**Backend:** node:sqlite (Node built-in) — full WAL + FTS5`);
@@ -4067,7 +4031,7 @@ class ToolHandler {
         if (pendingRefs > 0) {
             lines.push(`**Pending resolution:** ⚠ ${pendingRefs} references from an interrupted ` +
                 `index run — some caller/impact edges are missing until the next sync ` +
-                `(any file change triggers it, or run \`codegraph sync\`)`);
+                `(any file change triggers it, or run \`lattice sensor sync . --json\`)`);
         }
         lines.push('', '**Nodes by Kind:**');
         for (const [kind, count] of Object.entries(stats.nodesByKind)) {
@@ -4105,10 +4069,10 @@ class ToolHandler {
         return this.textResult(lines.join('\n'));
     }
     /**
-     * Handle codegraph_files - get project file structure from the index
+     * Handle lattice_sensor_files - get project file structure from the index
      */
     async handleFiles(args) {
-        const cg = this.getCodeGraph(args.projectPath);
+        const cg = this.getLatticeSensor(args.projectPath);
         const pathFilter = args.path;
         const pattern = args.pattern;
         const format = args.format || 'tree';
@@ -4117,7 +4081,7 @@ class ToolHandler {
         // Get all files from the index
         const allFiles = cg.getFiles();
         if (allFiles.length === 0) {
-            return this.textResult('No files indexed. Run `codegraph index` first.');
+            return this.textResult('No files indexed. Run `lattice sensor index` first.');
         }
         // Filter by path prefix. Stored paths are project-relative POSIX (e.g.
         // "src/foo.ts"), but agents commonly pass project-root variants like "/",
@@ -4328,7 +4292,7 @@ class ToolHandler {
         return containerHints.every((hint) => segments.some((seg) => seg === hint || seg.replace(/\.[^.]+$/, '') === hint));
     }
     /**
-     * Find ALL definitions matching a name, ranked, so codegraph_node can return
+     * Find ALL definitions matching a name, ranked, so lattice_sensor_node can return
      * every overload instead of guessing one (the wrong guess → a Read). Keepers
      * rank before generated stubs (.pb.go etc.); stable within a group preserves
      * FTS order. Returns [] when nothing matches; a qualified lookup that finds no
@@ -4548,10 +4512,10 @@ class ToolHandler {
             lines.push('', node.docstring);
         }
         if (outline) {
-            lines.push('', outline, '', `> Structural outline only. Read \`${node.filePath}\` or call codegraph_node on a specific member for its body.`);
+            lines.push('', outline, '', `> Structural outline only. Read \`${node.filePath}\` or call lattice_sensor_node on a specific member for its body.`);
         }
         else if (code) {
-            // Line-numbered (cat -n style, like codegraph_explore and Read) so the
+            // Line-numbered (cat -n style, like lattice_sensor_explore and Read) so the
             // agent can cite/edit exact lines without re-Reading the file for them.
             const numbered = node.startLine ? numberSourceLines(code, node.startLine) : code;
             lines.push('', '```' + node.language, numbered, '```');