homegraph 1.1.2 → 1.2.0

package/dist/mcp/query-pool.js

@@ -0,0 +1,297 @@
+"use strict";
+/**
+ * Query pool — runs CPU-heavy read-tool calls on a pool of worker threads so
+ * the shared daemon's main event loop stays free for the MCP transport.
+ *
+ * Why this exists: see {@link ./query-worker}. One daemon, one event loop, one
+ * synchronous SQLite connection serializes every concurrent `codegraph_explore`
+ * AND starves the transport (a 10-way wave delivered 0 transport heartbeats in
+ * 25s — responses can't flush until the whole batch drains, so clients time
+ * out). Spreading the dispatch across worker threads (each its own WAL read
+ * connection) restores true multi-core parallelism and an idle main loop.
+ *
+ * Properties:
+ *   - lazy growth: one warm worker on construct, grows to `size` on demand, so a
+ *     single-agent session pays for one connection and a 10-subagent burst grows
+ *     to the core budget.
+ *   - crash recovery: a dead worker is respawned and its in-flight call retried
+ *     once; a poison call that keeps crashing fails gracefully (never wedges the
+ *     pool). A crash budget trips a circuit breaker (`healthy` → false) so the
+ *     caller falls back to in-process dispatch instead of thrashing respawns.
+ *   - graceful backstop: a call that can't be served within `softTimeoutMs`
+ *     resolves with SUCCESS-shaped "busy, retry" guidance — never `isError`, so
+ *     a momentary overload can't teach the agent to abandon codegraph — instead
+ *     of hanging past the client's hard timeout.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryPool = void 0;
+exports.resolvePoolSize = resolvePoolSize;
+const worker_threads_1 = require("worker_threads");
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+/** Compiled sibling — `query-worker.js` lives next to this file in `dist/mcp/`. */
+const WORKER_FILE = path.join(__dirname, 'query-worker.js');
+/** Default linger before a queued call is answered with busy-guidance. */
+const DEFAULT_BUSY_TIMEOUT_MS = 45_000; // < the ~60s MCP client request timeout
+/** Hard ceiling on pool size regardless of core count / env. */
+const MAX_POOL_SIZE = 16;
+/**
+ * Total worker deaths before the pool declares itself unhealthy and the caller
+ * reverts to in-process dispatch. High enough to ride out a few transient
+ * crashes, low enough that a systematically-broken worker (e.g. a platform that
+ * can't spawn threads) degrades quickly instead of respawning forever.
+ */
+const CRASH_BUDGET = 12;
+/**
+ * Max workers cold-starting at once. A worker's cold start is heavy — full
+ * module load (tree-sitter etc.) + opening a large WAL DB — and starting the
+ * whole pool simultaneously thrashes CPU/I-O so badly it can stall the daemon's
+ * main loop for tens of seconds. Warming a couple at a time keeps each start
+ * fast; as one reports ready the next begins, so the pool still reaches full
+ * size within a few calls of a burst, just without the thundering herd.
+ */
+const MAX_CONCURRENT_SPAWN = 2;
+/**
+ * Resolve the pool size from the `CODEGRAPH_QUERY_POOL_SIZE` override and the
+ * machine's core count. `0` (or a negative) explicitly disables the pool (the
+ * caller serves in-process — today's behavior). Unset → `clamp(cores-1, 1, 16)`:
+ * leave a core for the main loop + OS, but never zero, since even one worker
+ * frees the transport and lets responses flush incrementally.
+ */
+function resolvePoolSize(envVal, cpuCount) {
+    if (envVal !== undefined && envVal !== '') {
+        const n = Number(envVal);
+        if (Number.isFinite(n) && n >= 0)
+            return Math.min(Math.floor(n), MAX_POOL_SIZE);
+        // non-numeric / negative → fall through to the default
+    }
+    return Math.max(1, Math.min(cpuCount - 1, MAX_POOL_SIZE));
+}
+function resolveBusyTimeoutMs() {
+    const raw = process.env.CODEGRAPH_QUERY_BUSY_TIMEOUT_MS;
+    if (raw === undefined || raw === '')
+        return DEFAULT_BUSY_TIMEOUT_MS;
+    const n = Number(raw);
+    if (!Number.isFinite(n) || n < 1000)
+        return DEFAULT_BUSY_TIMEOUT_MS;
+    return Math.floor(n);
+}
+/** Success-shaped overload guidance (NEVER isError — see the abandonment rule). */
+function busyGuidance(waitedMs) {
+    const secs = Math.max(1, Math.round(waitedMs / 1000));
+    return {
+        content: [{
+                type: 'text',
+                text: `CodeGraph is busy serving other concurrent requests right now (this call waited ${secs}s in the queue). ` +
+                    `This is NOT an error and the index is fine — wait a few seconds and retry this exact call; it will return normally. ` +
+                    `If you can't wait, use your built-in tools for just this one step.`,
+            }],
+    };
+}
+class QueryPool {
+    idle = [];
+    queue = [];
+    inflight = new Map();
+    workers = new Set();
+    // Workers spawned but not yet 'ready'. Growth must count these so a single
+    // first call (with the eager worker still starting) doesn't spawn the WHOLE
+    // pool at once — N simultaneous cold worker starts (each a full module load +
+    // a large DB open) saturate the box and starve the main loop. Grow only when
+    // the queue outstrips idle + pending.
+    pendingWorkers = new Set();
+    nextId = 1;
+    totalCrashes = 0;
+    destroyed = false;
+    root;
+    maxSize;
+    softTimeoutMs;
+    maxRetries;
+    createWorker;
+    constructor(opts) {
+        this.root = opts.root;
+        this.maxSize = Math.max(1, Math.min(opts.size ?? Math.max(1, os.cpus().length - 1), MAX_POOL_SIZE));
+        this.softTimeoutMs = opts.softTimeoutMs ?? resolveBusyTimeoutMs();
+        this.maxRetries = opts.maxRetries ?? 1;
+        this.createWorker = opts.createWorker ?? (() => new worker_threads_1.Worker(WORKER_FILE, { workerData: { root: this.root } }));
+        this.spawnOne(); // one eager warm worker, ready for the first call
+    }
+    /** Pool size cap (for logging/status). */
+    get size() { return this.maxSize; }
+    /** Live worker count (for tests/status). */
+    get liveWorkers() { return this.workers.size; }
+    /**
+     * False once the crash budget is exhausted (or after destroy). The ToolHandler
+     * checks this and falls back to in-process dispatch — a broken worker platform
+     * degrades to today's behavior instead of failing tool calls.
+     */
+    get healthy() {
+        return !this.destroyed && this.totalCrashes < CRASH_BUDGET;
+    }
+    spawnOne() {
+        if (this.destroyed || this.workers.size >= this.maxSize)
+            return;
+        let w;
+        try {
+            w = this.createWorker();
+        }
+        catch {
+            this.totalCrashes++; // counts toward the circuit breaker
+            return;
+        }
+        this.workers.add(w);
+        this.pendingWorkers.add(w);
+        w.on('message', (m) => this.onMessage(w, (m ?? {})));
+        w.on('error', () => this.onWorkerGone(w));
+        w.on('exit', (code) => { if (code !== 0)
+            this.onWorkerGone(w); });
+    }
+    onMessage(w, m) {
+        if (!m)
+            return;
+        if (m.type === 'ready') {
+            this.pendingWorkers.delete(w);
+            if (m.ok === false)
+                this.totalCrashes++; // hard open failure
+            this.idle.push(w);
+            this.drain();
+            return;
+        }
+        if (m.type === 'result') {
+            const job = this.inflight.get(w);
+            this.inflight.delete(w);
+            this.idle.push(w);
+            if (job)
+                this.settle(job, m.result ?? busyGuidance(0));
+            this.drain();
+        }
+    }
+    // A worker died (crash hook, OOM, segfault, exit≠0). Respawn a replacement and
+    // retry its in-flight job once; a job that keeps crashing workers fails
+    // gracefully so it can't loop the pool forever.
+    onWorkerGone(w) {
+        if (!this.workers.has(w))
+            return; // already handled (error+exit both fire)
+        this.workers.delete(w);
+        this.pendingWorkers.delete(w);
+        this.idle = this.idle.filter((x) => x !== w);
+        this.totalCrashes++;
+        const job = this.inflight.get(w);
+        this.inflight.delete(w);
+        try {
+            void w.terminate();
+        }
+        catch { /* already gone */ }
+        if (this.healthy)
+            this.spawnOne(); // keep capacity
+        if (job) {
+            if (job.retries < this.maxRetries && this.healthy) {
+                job.retries++;
+                this.queue.unshift(job); // head of line — retry promptly
+            }
+            else {
+                this.settle(job, { isError: true, content: [{ type: 'text', text: 'codegraph worker crashed; please retry the call.' }] });
+            }
+        }
+        this.drain();
+    }
+    drain() {
+        // Grow toward maxSize while queued work outstrips workers that are idle OR
+        // already on their way up (pending) — so we never spawn the whole pool for a
+        // single call whose eager worker just hasn't reported ready yet.
+        while (this.queue.length > this.idle.length + this.pendingWorkers.size &&
+            this.workers.size < this.maxSize &&
+            this.pendingWorkers.size < MAX_CONCURRENT_SPAWN &&
+            this.healthy) {
+            this.spawnOne();
+        }
+        while (this.idle.length && this.queue.length) {
+            // Skip jobs the backstop already answered.
+            let job;
+            while (this.queue.length && (job = this.queue.shift()) && job.settled)
+                job = undefined;
+            if (!job || job.settled)
+                break;
+            const w = this.idle.pop();
+            this.inflight.set(w, job);
+            w.postMessage({ type: 'call', id: job.id, toolName: job.toolName, args: job.args });
+        }
+    }
+    settle(job, result) {
+        if (job.settled)
+            return; // already answered (by backstop or worker)
+        job.settled = true;
+        if (job.softTimer)
+            clearTimeout(job.softTimer);
+        job.resolve(result);
+    }
+    /** Run a read tool on the pool. Always resolves (never rejects). */
+    run(toolName, args) {
+        return new Promise((resolve) => {
+            const job = {
+                id: this.nextId++, toolName, args, resolve,
+                retries: 0, settled: false, enqueuedAt: Date.now(),
+            };
+            // Don't let the caller wait past softTimeoutMs. The worker may still be
+            // busy (we can't cancel synchronous CPU), but the CLIENT gets a prompt,
+            // success-shaped "retry" instead of a hard timeout.
+            job.softTimer = setTimeout(() => {
+                if (!job.settled)
+                    this.settle(job, busyGuidance(Date.now() - job.enqueuedAt));
+            }, this.softTimeoutMs);
+            job.softTimer.unref?.();
+            this.queue.push(job);
+            this.drain();
+        });
+    }
+    /** Terminate all workers and answer any outstanding calls gracefully. */
+    async destroy() {
+        if (this.destroyed)
+            return;
+        this.destroyed = true;
+        const ws = [...this.workers];
+        this.workers.clear();
+        this.pendingWorkers.clear();
+        this.idle = [];
+        for (const job of [...this.inflight.values(), ...this.queue]) {
+            this.settle(job, { isError: true, content: [{ type: 'text', text: 'codegraph is shutting down; retry shortly.' }] });
+        }
+        this.inflight.clear();
+        this.queue = [];
+        await Promise.all(ws.map((w) => Promise.resolve(w.terminate()).catch(() => { })));
+    }
+}
+exports.QueryPool = QueryPool;
+//# sourceMappingURL=query-pool.js.map

package/dist/mcp/query-pool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-pool.js","sourceRoot":"","sources":["../../src/mcp/query-pool.ts"],"names":[],"mappings":"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"}

package/dist/mcp/query-worker.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Query worker thread — issue: concurrent MCP tool calls starve the daemon.
+ *
+ * The shared daemon serves every session on ONE event loop with synchronous
+ * `node:sqlite`. `codegraph_explore` is CPU-heavy (FTS + RWR/personalized-
+ * PageRank + impact + output building) stitched together by microtask `await`s,
+ * so N concurrent explores keep the microtask queue continuously full and
+ * starve the macrotask phases — timers AND socket I/O. The transport freezes:
+ * no response flushes, no request is read, until the whole batch drains. With
+ * ~10 subagents that routinely exceeds the MCP client's request timeout.
+ *
+ * This worker moves the heavy read-tool dispatch OFF the daemon's main loop.
+ * Each worker owns its OWN read connection (node:sqlite WAL allows N concurrent
+ * readers across connections — verified: a worker reader sees the main writer's
+ * committed catch-up/watcher writes), so {@link QueryPool} runs N tool calls in
+ * true parallel up to core count while the main loop stays free for the MCP
+ * transport. The worker runs {@link ToolHandler.executeReadTool} — validation +
+ * dispatch + error classification — and returns the raw {@link ToolResult}; the
+ * MAIN thread keeps the catch-up gate, the watcher-state notices (staleness /
+ * worktree), `codegraph_status`, and telemetry, none of which a watcher-less
+ * read connection can answer.
+ */
+export {};
+//# sourceMappingURL=query-worker.d.ts.map

package/dist/mcp/query-worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-worker.d.ts","sourceRoot":"","sources":["../../src/mcp/query-worker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG"}

package/dist/mcp/query-worker.js

@@ -0,0 +1,87 @@
+"use strict";
+/**
+ * Query worker thread — issue: concurrent MCP tool calls starve the daemon.
+ *
+ * The shared daemon serves every session on ONE event loop with synchronous
+ * `node:sqlite`. `codegraph_explore` is CPU-heavy (FTS + RWR/personalized-
+ * PageRank + impact + output building) stitched together by microtask `await`s,
+ * so N concurrent explores keep the microtask queue continuously full and
+ * starve the macrotask phases — timers AND socket I/O. The transport freezes:
+ * no response flushes, no request is read, until the whole batch drains. With
+ * ~10 subagents that routinely exceeds the MCP client's request timeout.
+ *
+ * This worker moves the heavy read-tool dispatch OFF the daemon's main loop.
+ * Each worker owns its OWN read connection (node:sqlite WAL allows N concurrent
+ * readers across connections — verified: a worker reader sees the main writer's
+ * committed catch-up/watcher writes), so {@link QueryPool} runs N tool calls in
+ * true parallel up to core count while the main loop stays free for the MCP
+ * transport. The worker runs {@link ToolHandler.executeReadTool} — validation +
+ * dispatch + error classification — and returns the raw {@link ToolResult}; the
+ * MAIN thread keeps the catch-up gate, the watcher-state notices (staleness /
+ * worktree), `codegraph_status`, and telemetry, none of which a watcher-less
+ * read connection can answer.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const worker_threads_1 = require("worker_threads");
+// Mirror the engine's lazy-require of the heavy CodeGraph + tools chain. This
+// module is only ever loaded as a Worker, so the require runs once on spawn.
+const loadCodeGraph = () => require('../index').default;
+const loadToolHandler = () => require('./tools').ToolHandler;
+if (worker_threads_1.parentPort) {
+    const port = worker_threads_1.parentPort;
+    const { root } = worker_threads_1.workerData;
+    // Open the default project's READ connection once, at spawn. Other repos are
+    // opened lazily on first cross-project (projectPath) call by the ToolHandler's
+    // own per-handler cache. openSync does not start a watcher — workers are pure
+    // readers; the single watcher/writer stays on the daemon's main thread.
+    let handler = null;
+    let initError = null;
+    try {
+        const cg = loadCodeGraph().openSync(root);
+        handler = new (loadToolHandler())(cg);
+    }
+    catch (err) {
+        initError = err instanceof Error ? err.message : String(err);
+    }
+    // Tell the pool we're up. `ok:false` lets the pool count a hard open failure
+    // against its crash budget (→ fall back to in-process) without hanging.
+    port.postMessage({ type: 'ready', ok: initError === null, error: initError });
+    port.on('message', (msg) => {
+        if (!msg || msg.type !== 'call')
+            return;
+        void serve(msg);
+    });
+    const serve = async (msg) => {
+        // Test-only crash hook so the pool's worker-recovery path is exercisable
+        // deterministically. Gated behind an env flag only the suite sets — inert in
+        // normal operation (and `__test_crash__` isn't a real tool name anyway).
+        if (msg.toolName === '__test_crash__' && process.env.CODEGRAPH_QUERY_WORKER_ALLOW_TEST_CRASH === '1') {
+            process.exit(13);
+        }
+        if (!handler) {
+            port.postMessage({
+                type: 'result',
+                id: msg.id,
+                result: errorResult(`codegraph worker could not open the project: ${initError}`),
+            });
+            return;
+        }
+        try {
+            // executeReadTool already classifies NotIndexed/PathRefusal/internal errors
+            // into a ToolResult and never throws — the catch is belt-and-suspenders.
+            const result = await handler.executeReadTool(msg.toolName, msg.args);
+            port.postMessage({ type: 'result', id: msg.id, result });
+        }
+        catch (err) {
+            port.postMessage({
+                type: 'result',
+                id: msg.id,
+                result: errorResult(err instanceof Error ? err.message : String(err)),
+            });
+        }
+    };
+}
+function errorResult(text) {
+    return { isError: true, content: [{ type: 'text', text }] };
+}
+//# sourceMappingURL=query-worker.js.map

package/dist/mcp/query-worker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-worker.js","sourceRoot":"","sources":["../../src/mcp/query-worker.ts"],"names":[],"mappings":"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"}

package/dist/mcp/server-instructions.d.ts

@@ -11,13 +11,11 @@
  *   - Reinforce "explore instead of Read/Grep" for indexed code
  *   - Anti-patterns (don't re-verify with grep; don't hand-reconstruct flows)
  *
- * Keep it tight. The agent reads this every session — long instructions
- * burn tokens. The DEFAULT MCP surface is `homegraph_explore` ALONE (see
- * DEFAULT_MCP_TOOLS in tools.ts) — reference only that tool here. The other
- * tools (node/search/callers/…) stay defined and are re-enablable via
- * HOMEGRAPH_MCP_TOOLS, but they are NOT listed to agents, so don't name them.
+ * HomeGraph exposes the full tool surface by default (search, node, explore,
+ * spec tools, …). Lead with homegraph_explore for structural questions; the
+ * other tools are available when a narrower step helps.
  */
-export declare const SERVER_INSTRUCTIONS = "# Codegraph \u2014 code intelligence over an indexed knowledge graph\n\nCodegraph is a SQLite knowledge graph of every symbol, edge, and file in\nthe workspace \u2014 pre-computed structure you would otherwise re-derive by\nreading files (cached intelligence: thousands of parse/trace decisions you\ndon't pay to re-reason each run). Reads are sub-millisecond; the index lags\nwrites by ~1s through the file watcher. Reach for it BEFORE *and* while\nwriting or editing code \u2014 not just for questions: one call returns the\nverbatim source PLUS who calls it and what it affects, so you edit with the\nblast radius in view. More accurate context, in far fewer tokens and\nround-trips than reading files yourself.\n\n## One tool: homegraph_explore \u2014 use it instead of reading files\n\nThere is a single tool, `homegraph_explore`, and it is Read-equivalent. It\ntakes either a natural-language question or a bag of symbol/file names and\nreturns the **verbatim, line-numbered source** of the relevant symbols\ngrouped by file \u2014 the same `<n>\\t<line>` shape `Read` gives you, safe to\n`Edit` from \u2014 PLUS the call path among them (including dynamic-dispatch hops\nlike callbacks, React re-render, and JSX children that grep can't follow) and\na blast-radius summary of what depends on them.\n\nWhether you're answering \"how does X work\" or implementing a change (fixing a\nbug, adding a feature), call `homegraph_explore` before you Read. ONE call\nusually answers the whole question. Codegraph IS the pre-built search index \u2014\nso running your own grep + read loop, or delegating the lookup to a separate\nfile-reading sub-task/agent, repeats work homegraph already did and costs more\nfor the same answer. A direct homegraph answer is typically one to a few\ncalls; a grep/read exploration is dozens.\n\n## How to query\n\n- **Almost any question \u2014 \"how does X work\", architecture, a bug, \"what/where is X\", or surveying an area** \u2192 `homegraph_explore` with a natural-language question or the relevant names. ONE capped call returns the verbatim source grouped by file; most often the ONLY call you need.\n- **\"How does X reach/become Y? / the flow / the path from X to Y\"** \u2192 `homegraph_explore`, naming the symbols that span the flow (e.g. `mutateElement renderScene`) \u2014 it surfaces the call path among them, riding dynamic-dispatch hops, and returns their source.\n- **Reading or editing a file/symbol you can name** \u2192 put its name or file path in the `homegraph_explore` query \u2014 it returns that current line-numbered source (safe to `Edit` from) with the call path and blast radius attached, so you don't Read it separately. For an overloaded name it returns every matching definition's body in one call.\n- **Need more?** Call `homegraph_explore` again with more specific names \u2014 treat the source it returns as already Read.\n\n## Anti-patterns\n\n- **Trust homegraph's results \u2014 don't re-verify them with grep.** They come from a full AST parse; re-checking with grep is slower, less accurate, and wastes context.\n- **Don't grep or Read first** to find or understand indexed code \u2014 ONE `homegraph_explore` returns the relevant symbols' source together in a single round-trip. Reach for raw `Read`/`Grep` only to confirm a specific detail homegraph didn't cover, or for what homegraph doesn't index (configs, docs).\n- **Don't reconstruct a flow by hand** \u2014 name the endpoints in one `homegraph_explore` and it surfaces the path between them, dynamic-dispatch hops included.\n- **After editing, check the staleness banner.** When a tool response starts with \"\u26A0\uFE0F Some files referenced below were edited since the last index sync\u2026\", the listed files are pending re-index \u2014 Read those specific files for accurate content. Every file NOT in that banner is fresh, so still trust homegraph. A different, rarer banner \u2014 \"\u26A0\uFE0F HomeGraph auto-sync is DISABLED\u2026\" \u2014 means live watching stopped entirely (the whole index is frozen, not just a few files); until it's resolved, Read files directly to confirm anything that may have changed.\n\n## Limitations\n\n- If a tool reports a project isn't indexed (no `.homegraph/`), stop calling homegraph tools for that project for the rest of the session and use your built-in tools there instead. Indexing is the user's decision \u2014 mention they can run `homegraph init` if it comes up, but don't run it yourself.\n- Index lags file writes by ~1 second.\n- Cross-file resolution is best-effort name matching; ambiguous calls may return multiple candidates.\n- No live correctness validation \u2014 that's still the TypeScript compiler / test suite / linter's job. Codegraph supplements those with structural context they don't have.\n";
+export declare const SERVER_INSTRUCTIONS = "# HomeGraph \u2014 code intelligence over an indexed knowledge graph\n\nHomeGraph is a SQLite knowledge graph of every symbol, edge, and file in\nthe workspace \u2014 pre-computed structure you would otherwise re-derive by\nreading files (cached intelligence: thousands of parse/trace decisions you\ndon't pay to re-reason each run). Reads are sub-millisecond; the index lags\nwrites by ~1s through the file watcher. Reach for it BEFORE *and* while\nwriting or editing code \u2014 not just for questions: one call returns the\nverbatim source PLUS who calls it and what it affects, so you edit with the\nblast radius in view. More accurate context, in far fewer tokens and\nround-trips than reading files yourself.\n\n## Primary tool: homegraph_explore \u2014 use it instead of reading files\n\nFor structural and flow questions, `homegraph_explore` is Read-equivalent. It\ntakes either a natural-language question or a bag of symbol/file names and\nreturns the **verbatim, line-numbered source** of the relevant symbols\ngrouped by file \u2014 the same `<n>\\t<line>` shape `Read` gives you, safe to\n`Edit` from \u2014 PLUS the call path among them (including dynamic-dispatch hops\nlike callbacks, React re-render, and JSX children that grep can't follow) and\na blast-radius summary of what depends on them.\n\nWhether you're answering \"how does X work\" or implementing a change (fixing a\nbug, adding a feature), call `homegraph_explore` before you Read. ONE call\nusually answers the whole question. HomeGraph IS the pre-built search index \u2014\nso running your own grep + read loop, or delegating the lookup to a separate\nfile-reading sub-task/agent, repeats work homegraph already did and costs more\nfor the same answer. A direct homegraph answer is typically one to a few\ncalls; a grep/read exploration is dozens.\n\n## How to query\n\n- **Almost any question \u2014 \"how does X work\", architecture, a bug, \"what/where is X\", or surveying an area** \u2192 `homegraph_explore` with a natural-language question or the relevant names. ONE capped call returns the verbatim source grouped by file; most often the ONLY call you need.\n- **\"How does X reach/become Y? / the flow / the path from X to Y\"** \u2192 `homegraph_explore`, naming the symbols that span the flow (e.g. `mutateElement renderScene`) \u2014 it surfaces the call path among them, riding dynamic-dispatch hops, and returns their source.\n- **Reading or editing a file/symbol you can name** \u2192 put its name or file path in the `homegraph_explore` query \u2014 it returns that current line-numbered source (safe to `Edit` from) with the call path and blast radius attached, so you don't Read it separately. For an overloaded name it returns every matching definition's body in one call.\n- **Need more?** Call `homegraph_explore` again with more specific names \u2014 treat the source it returns as already Read.\n\n## Anti-patterns\n\n- **Trust homegraph's results \u2014 don't re-verify them with grep.** They come from a full AST parse; re-checking with grep is slower, less accurate, and wastes context.\n- **Don't grep or Read first** to find or understand indexed code \u2014 ONE `homegraph_explore` returns the relevant symbols' source together in a single round-trip. Reach for raw `Read`/`Grep` only to confirm a specific detail homegraph didn't cover, or for what homegraph doesn't index (configs, docs).\n- **Don't reconstruct a flow by hand** \u2014 name the endpoints in one `homegraph_explore` and it surfaces the path between them, dynamic-dispatch hops included.\n- **After editing, check the staleness banner.** When a tool response starts with \"\u26A0\uFE0F Some files referenced below were edited since the last index sync\u2026\", the listed files are pending re-index \u2014 Read those specific files for accurate content. Every file NOT in that banner is fresh, so still trust homegraph. A different, rarer banner \u2014 \"\u26A0\uFE0F HomeGraph auto-sync is DISABLED\u2026\" \u2014 means live watching stopped entirely (the whole index is frozen, not just a few files); until it's resolved, Read files directly to confirm anything that may have changed.\n\n## Limitations\n\n- If a tool reports a project isn't indexed (no `.homegraph/`), stop calling homegraph tools for that project for the rest of the session and use your built-in tools there instead. Indexing is the user's decision \u2014 mention they can run `homegraph init` if it comes up, but don't run it yourself.\n- Index lags file writes by ~1 second.\n- Cross-file resolution is best-effort name matching; ambiguous calls may return multiple candidates.\n- No live correctness validation \u2014 that's still the TypeScript compiler / test suite / linter's job. HomeGraph supplements those with structural context they don't have.\n";
 /**
  * Instructions variant sent when the server's own root has NO homegraph index.
  *
@@ -30,5 +28,5 @@ export declare const SERVER_INSTRUCTIONS = "# Codegraph \u2014 code intelligence
  * project playbook ({@link SERVER_INSTRUCTIONS}) is sent instead when the root
  * IS indexed, so the common case stays tight.
  */
-export declare const SERVER_INSTRUCTIONS_NO_ROOT_INDEX = "# Codegraph \u2014 available (per-project; pass projectPath)\n\nCodegraph is a SQLite knowledge graph of a codebase's symbols, edges, and\nfiles: one `homegraph_explore` call returns the verbatim, line-numbered source\nof the relevant symbols PLUS the call paths between them and a blast-radius\nsummary \u2014 replacing a grep + Read loop with one round-trip.\n\nThis server started somewhere with no `.homegraph/` of its own, so there is no\ndefault project \u2014 but the tools are available and work **per project**:\n\n- To query a project that HAS a `.homegraph/` index (e.g. a service inside a\n  monorepo, or a second repo), pass its path as `projectPath` to\n  `homegraph_explore` (and any other homegraph tool). Codegraph resolves the\n  nearest `.homegraph/` at or above that path and answers from it \u2014 for as many\n  projects as you like in one session.\n- For a project with no `.homegraph/`, use your built-in tools (Read/Grep/Glob)\n  for that project. Indexing is the user's decision \u2014 don't run it yourself, but\n  if it comes up they can run `homegraph init` in a project to enable homegraph\n  there (a new index is picked up live, no restart).\n";
+export declare const SERVER_INSTRUCTIONS_NO_ROOT_INDEX = "# HomeGraph \u2014 available (per-project; pass projectPath)\n\nHomeGraph is a SQLite knowledge graph of a codebase's symbols, edges, and\nfiles: one `homegraph_explore` call returns the verbatim, line-numbered source\nof the relevant symbols PLUS the call paths between them and a blast-radius\nsummary \u2014 replacing a grep + Read loop with one round-trip.\n\nThis server started somewhere with no `.homegraph/` of its own, so there is no\ndefault project \u2014 but the tools are available and work **per project**:\n\n- To query a project that HAS a `.homegraph/` index (e.g. a service inside a\n  monorepo, or a second repo), pass its path as `projectPath` to\n  `homegraph_explore` (and any other homegraph tool). HomeGraph resolves the\n  nearest `.homegraph/` at or above that path and answers from it \u2014 for as many\n  projects as you like in one session.\n- For a project with no `.homegraph/`, use your built-in tools (Read/Grep/Glob)\n  for that project. Indexing is the user's decision \u2014 don't run it yourself, but\n  if it comes up they can run `homegraph init` in a project to enable homegraph\n  there (a new index is picked up live, no restart).\n";
 //# sourceMappingURL=server-instructions.d.ts.map

package/dist/mcp/server-instructions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server-instructions.d.ts","sourceRoot":"","sources":["../../src/mcp/server-instructions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,mBAAmB,qsJAkD/B,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,iCAAiC,4pCAmB7C,CAAC"}
+{"version":3,"file":"server-instructions.d.ts","sourceRoot":"","sources":["../../src/mcp/server-instructions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,mBAAmB,4sJAkD/B,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,iCAAiC,4pCAmB7C,CAAC"}