@bharanidev/bhgraph-win32-arm64 1.0.0

package/lib/dist/mcp/server-instructions.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SERVER_INSTRUCTIONS_NO_ROOT_INDEX = exports.SERVER_INSTRUCTIONS = void 0;
+/**
+ * Server-level instructions emitted in the MCP `initialize` response.
+ *
+ * MCP clients (Claude Code, Cursor, opencode, LangChain, OpenAI Agent
+ * SDK, …) surface this text in the agent's system prompt automatically,
+ * giving the agent a high-level playbook for the bhgraph toolset
+ * before it sees individual tool descriptions.
+ *
+ * Goals when editing this:
+ *   - Lead the agent to bhgraph_explore for any structural/flow question
+ *   - 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 `bhgraph_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
+ * BHGRAPH_MCP_TOOLS, but they are NOT listed to agents, so don't name them.
+ */
+exports.SERVER_INSTRUCTIONS = `# BHgraph — code intelligence over an indexed knowledge graph
+
+BHgraph is a SQLite knowledge graph of every symbol, edge, and file in
+the workspace — pre-computed structure you would otherwise re-derive by
+reading files (cached intelligence: thousands of parse/trace decisions you
+don't pay to re-reason each run). Reads are sub-millisecond; the index lags
+writes by ~1s through the file watcher. Reach for it BEFORE *and* while
+writing or editing code — not just for questions: one call returns the
+verbatim source PLUS who calls it and what it affects, so you edit with the
+blast radius in view. More accurate context, in far fewer tokens and
+round-trips than reading files yourself.
+
+## One tool: bhgraph_explore — use it instead of reading files
+
+There is a single tool, \`bhgraph_explore\`, and it is Read-equivalent. It
+takes either a natural-language question or a bag of symbol/file names and
+returns the **verbatim, line-numbered source** of the relevant symbols
+grouped by file — the same \`<n>\\t<line>\` shape \`Read\` gives you, safe to
+\`Edit\` from — PLUS the call path among them (including dynamic-dispatch hops
+like callbacks, React re-render, and JSX children that grep can't follow) and
+a blast-radius summary of what depends on them.
+
+Whether you're answering "how does X work" or implementing a change (fixing a
+bug, adding a feature), call \`bhgraph_explore\` before you Read. ONE call
+usually answers the whole question. BHgraph IS the pre-built search index —
+so running your own grep + read loop, or delegating the lookup to a separate
+file-reading sub-task/agent, repeats work bhgraph already did and costs more
+for the same answer. A direct bhgraph answer is typically one to a few
+calls; a grep/read exploration is dozens.
+
+## How to query
+
+- **Almost any question — "how does X work", architecture, a bug, "what/where is X", or surveying an area** → \`bhgraph_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.
+- **"How does X reach/become Y? / the flow / the path from X to Y"** → \`bhgraph_explore\`, naming the symbols that span the flow (e.g. \`mutateElement renderScene\`) — it surfaces the call path among them, riding dynamic-dispatch hops, and returns their source.
+- **Reading or editing a file/symbol you can name** → put its name or file path in the \`bhgraph_explore\` query — 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.
+- **Need more?** Call \`bhgraph_explore\` again with more specific names — treat the source it returns as already Read.
+
+## Anti-patterns
+
+- **Trust bhgraph's results — 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.
+- **Don't grep or Read first** to find or understand indexed code — ONE \`bhgraph_explore\` returns the relevant symbols' source together in a single round-trip. Reach for raw \`Read\`/\`Grep\` only to confirm a specific detail bhgraph didn't cover, or for what bhgraph doesn't index (configs, docs).
+- **Don't reconstruct a flow by hand** — name the endpoints in one \`bhgraph_explore\` and it surfaces the path between them, dynamic-dispatch hops included.
+- **After editing, check the staleness banner.** When a tool response starts with "⚠️ Some files referenced below were edited since the last index sync…", the listed files are pending re-index — Read those specific files for accurate content. Every file NOT in that banner is fresh, so still trust bhgraph. A different, rarer banner — "⚠️ BHGraph auto-sync is DISABLED…" — 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.
+
+## Limitations
+
+- If a tool reports a project isn't indexed (no \`.bhgraph/\`), stop calling bhgraph tools for that project for the rest of the session and use your built-in tools there instead. Indexing is the user's decision — mention they can run \`bhgraph init\` if it comes up, but don't run it yourself.
+- Index lags file writes by ~1 second.
+- Cross-file resolution is best-effort name matching; ambiguous calls may return multiple candidates.
+- No live correctness validation — that's still the TypeScript compiler / test suite / linter's job. BHgraph supplements those with structural context they don't have.
+`;
+/**
+ * Instructions variant sent when the server's own root has NO bhgraph index.
+ *
+ * The tools are still exposed (gating tool availability on whether `./` has an
+ * index is the bug behind #964: it breaks monorepos where only sub-projects are
+ * indexed, and a server that started before `bhgraph init` never surfaces the
+ * tools afterward). Instead of an "inactive" note, this variant tells the agent
+ * bhgraph works **per project**: there's no default project to query, so pass
+ * a `projectPath` to any project that HAS a `.bhgraph/`. The full single-
+ * project playbook ({@link SERVER_INSTRUCTIONS}) is sent instead when the root
+ * IS indexed, so the common case stays tight.
+ */
+exports.SERVER_INSTRUCTIONS_NO_ROOT_INDEX = `# BHgraph — available (per-project; pass projectPath)
+
+BHgraph is a SQLite knowledge graph of a codebase's symbols, edges, and
+files: one \`bhgraph_explore\` call returns the verbatim, line-numbered source
+of the relevant symbols PLUS the call paths between them and a blast-radius
+summary — replacing a grep + Read loop with one round-trip.
+
+This server started somewhere with no \`.bhgraph/\` of its own, so there is no
+default project — but the tools are available and work **per project**:
+
+- To query a project that HAS a \`.bhgraph/\` index (e.g. a service inside a
+  monorepo, or a second repo), pass its path as \`projectPath\` to
+  \`bhgraph_explore\` (and any other bhgraph tool). BHgraph resolves the
+  nearest \`.bhgraph/\` at or above that path and answers from it — for as many
+  projects as you like in one session.
+- For a project with no \`.bhgraph/\`, use your built-in tools (Read/Grep/Glob)
+  for that project. Indexing is the user's decision — don't run it yourself, but
+  if it comes up they can run \`bhgraph init\` in a project to enable bhgraph
+  there (a new index is picked up live, no restart).
+`;
+//# sourceMappingURL=server-instructions.js.map

package/lib/dist/mcp/server-instructions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-instructions.js","sourceRoot":"","sources":["../../src/mcp/server-instructions.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACU,QAAA,mBAAmB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkDlC,CAAC;AAEF;;;;;;;;;;;GAWG;AACU,QAAA,iCAAiC,GAAG;;;;;;;;;;;;;;;;;;;CAmBhD,CAAC"}

package/lib/dist/mcp/session.d.ts

@@ -0,0 +1,79 @@
+/**
+ * MCP per-connection session — speaks the JSON-RPC protocol (initialize,
+ * tools/list, tools/call) over a single {@link JsonRpcTransport}. It owns
+ * per-client state only (which protocol version the client asked for, whether
+ * it advertised `roots`, the one-shot roots/list latch); the heavyweight
+ * resources (BHGraph, watcher, ToolHandler) live in the shared
+ * {@link MCPEngine} so daemon mode can collapse N inotify sets / DB handles
+ * to one.
+ *
+ * The state-machine itself mirrors what `MCPServer` used to do inline before
+ * issue #411 split it out — the same regression tests in
+ * `__tests__/mcp-initialize.test.ts` still drive this code path.
+ */
+import { JsonRpcTransport } from './transport';
+import { MCPEngine } from './engine';
+/**
+ * MCP Server Info — kept on the session because some clients log it. The
+ * version tracks the real package version (was a hard-coded '0.1.0').
+ */
+export declare const SERVER_INFO: {
+    name: string;
+    version: string;
+};
+/** MCP Protocol Version (latest the server claims). */
+export declare const PROTOCOL_VERSION = "2024-11-05";
+export interface MCPSessionOptions {
+    /**
+     * Explicit project path from the `--path` CLI flag. When set, the session
+     * will not bother asking the client for `roots/list` — we already know
+     * where the project lives.
+     */
+    explicitProjectPath?: string | null;
+}
+/**
+ * One MCP client's view of the server. Created fresh per stdio launch
+ * (direct mode) or per socket connection (daemon mode).
+ */
+export declare class MCPSession {
+    private transport;
+    private engine;
+    private clientSupportsRoots;
+    /** From the initialize handshake — attributes usage rollups to the agent host. */
+    private clientInfo;
+    private rootsAttempted;
+    private resolvePromise;
+    private explicitProjectPath;
+    constructor(transport: JsonRpcTransport, engine: MCPEngine, opts?: MCPSessionOptions);
+    /**
+     * Start handling messages from the transport. Returns immediately — the
+     * session lives for as long as the transport is open.
+     */
+    start(): void;
+    /**
+     * Tear down the session. Does NOT touch the engine (the engine may serve
+     * other sessions) or call `process.exit` (the daemon decides when to exit).
+     */
+    stop(): void;
+    /** Underlying transport — exposed for daemon-side close hooks. */
+    getTransport(): JsonRpcTransport;
+    private handleMessage;
+    private handleInitialize;
+    private handleToolsList;
+    private handleToolsCall;
+    /**
+     * Lazy default-project resolution. Three layers:
+     *   1. await the in-flight init kicked off from `handleInitialize` (if any);
+     *   2. if still uninitialized and we never asked the client for its roots,
+     *      do so now (one-shot); fall back to cwd if the client lacks roots;
+     *   3. last-resort: re-walk from the best candidate — picks up projects
+     *      that were `bhgraph init`'d *after* the server started.
+     */
+    private retryInitIfNeeded;
+    /**
+     * Ask the client for its workspace root via `roots/list` and open the
+     * first one. Falls back to `process.cwd()` on timeout or empty answer.
+     */
+    private initFromRoots;
+}
+//# sourceMappingURL=session.d.ts.map

package/lib/dist/mcp/session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../src/mcp/session.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,EAAuC,gBAAgB,EAAc,MAAM,aAAa,CAAC;AAChG,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAOrC;;;GAGG;AAGH,eAAO,MAAM,WAAW;;;CAGvB,CAAC;AAEF,uDAAuD;AACvD,eAAO,MAAM,gBAAgB,eAAe,CAAC;AAmC7C,MAAM,WAAW,iBAAiB;IAChC;;;;OAIG;IACH,mBAAmB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACrC;AAED;;;GAGG;AACH,qBAAa,UAAU;IASnB,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,MAAM;IAThB,OAAO,CAAC,mBAAmB,CAAS;IACpC,kFAAkF;IAClF,OAAO,CAAC,UAAU,CAAyB;IAC3C,OAAO,CAAC,cAAc,CAAS;IAC/B,OAAO,CAAC,cAAc,CAA8B;IACpD,OAAO,CAAC,mBAAmB,CAAgB;gBAGjC,SAAS,EAAE,gBAAgB,EAC3B,MAAM,EAAE,SAAS,EACzB,IAAI,GAAE,iBAAsB;IAK9B;;;OAGG;IACH,KAAK,IAAI,IAAI;IAIb;;;OAGG;IACH,IAAI,IAAI,IAAI;IAIZ,kEAAkE;IAClE,YAAY,IAAI,gBAAgB;YAIlB,aAAa;YA0Cb,gBAAgB;YA0DhB,eAAe;YAkBf,eAAe;IAiC7B;;;;;;;OAOG;YACW,iBAAiB;IAyB/B;;;OAGG;YACW,aAAa;CAgB5B"}

package/lib/dist/mcp/session.js

@@ -0,0 +1,330 @@
+"use strict";
+/**
+ * MCP per-connection session — speaks the JSON-RPC protocol (initialize,
+ * tools/list, tools/call) over a single {@link JsonRpcTransport}. It owns
+ * per-client state only (which protocol version the client asked for, whether
+ * it advertised `roots`, the one-shot roots/list latch); the heavyweight
+ * resources (BHGraph, watcher, ToolHandler) live in the shared
+ * {@link MCPEngine} so daemon mode can collapse N inotify sets / DB handles
+ * to one.
+ *
+ * The state-machine itself mirrors what `MCPServer` used to do inline before
+ * issue #411 split it out — the same regression tests in
+ * `__tests__/mcp-initialize.test.ts` still drive this code path.
+ */
+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.MCPSession = exports.PROTOCOL_VERSION = exports.SERVER_INFO = void 0;
+const path = __importStar(require("path"));
+const transport_1 = require("./transport");
+const tools_1 = require("./tools");
+const server_instructions_1 = require("./server-instructions");
+const version_1 = require("./version");
+const directory_1 = require("../directory");
+const telemetry_1 = require("../telemetry");
+/**
+ * MCP Server Info — kept on the session because some clients log it. The
+ * version tracks the real package version (was a hard-coded '0.1.0').
+ */
+// Exported so the proxy can answer `initialize` locally with the IDENTICAL
+// payload the daemon would send — no drift between the two handshake paths.
+exports.SERVER_INFO = {
+    name: 'bhgraph',
+    version: version_1.BHGraphPackageVersion,
+};
+/** MCP Protocol Version (latest the server claims). */
+exports.PROTOCOL_VERSION = '2024-11-05';
+/**
+ * How long to wait for the client's `roots/list` response before giving up
+ * and falling back to the process cwd.
+ */
+const ROOTS_LIST_TIMEOUT_MS = 5000;
+/**
+ * Convert a file:// URI to a filesystem path. Handles URL encoding and
+ * Windows drive letter paths.
+ */
+function fileUriToPath(uri) {
+    try {
+        const url = new URL(uri);
+        let filePath = decodeURIComponent(url.pathname);
+        if (process.platform === 'win32' && /^\/[a-zA-Z]:/.test(filePath)) {
+            filePath = filePath.slice(1);
+        }
+        return path.resolve(filePath);
+    }
+    catch {
+        return uri.replace(/^file:\/\/\/?/, '');
+    }
+}
+/** First usable filesystem path from a `roots/list` result, or null. */
+function firstRootPath(result) {
+    if (!result || typeof result !== 'object')
+        return null;
+    const roots = result.roots;
+    if (!Array.isArray(roots) || roots.length === 0)
+        return null;
+    const first = roots[0];
+    if (typeof first?.uri !== 'string')
+        return null;
+    return fileUriToPath(first.uri);
+}
+/**
+ * One MCP client's view of the server. Created fresh per stdio launch
+ * (direct mode) or per socket connection (daemon mode).
+ */
+class MCPSession {
+    transport;
+    engine;
+    clientSupportsRoots = false;
+    /** From the initialize handshake — attributes usage rollups to the agent host. */
+    clientInfo;
+    rootsAttempted = false;
+    resolvePromise = null;
+    explicitProjectPath;
+    constructor(transport, engine, opts = {}) {
+        this.transport = transport;
+        this.engine = engine;
+        this.explicitProjectPath = opts.explicitProjectPath ?? null;
+    }
+    /**
+     * Start handling messages from the transport. Returns immediately — the
+     * session lives for as long as the transport is open.
+     */
+    start() {
+        this.transport.start(this.handleMessage.bind(this));
+    }
+    /**
+     * Tear down the session. Does NOT touch the engine (the engine may serve
+     * other sessions) or call `process.exit` (the daemon decides when to exit).
+     */
+    stop() {
+        this.transport.stop();
+    }
+    /** Underlying transport — exposed for daemon-side close hooks. */
+    getTransport() {
+        return this.transport;
+    }
+    async handleMessage(message) {
+        const isRequest = 'id' in message;
+        switch (message.method) {
+            case 'initialize':
+                if (isRequest)
+                    await this.handleInitialize(message);
+                break;
+            case 'initialized':
+                // Notification that client has finished initialization — no action needed.
+                break;
+            case 'tools/list':
+                if (isRequest)
+                    await this.handleToolsList(message);
+                break;
+            case 'tools/call':
+                if (isRequest)
+                    await this.handleToolsCall(message);
+                break;
+            case 'ping':
+                if (isRequest)
+                    this.transport.sendResult(message.id, {});
+                break;
+            case 'resources/list':
+                // We expose no MCP resources, but some clients (opencode, Codex) probe
+                // for them on connect; reply with an empty list instead of a
+                // MethodNotFound error that surfaces as a scary `-32601` log line. (#621)
+                if (isRequest)
+                    this.transport.sendResult(message.id, { resources: [] });
+                break;
+            case 'resources/templates/list':
+                if (isRequest)
+                    this.transport.sendResult(message.id, { resourceTemplates: [] });
+                break;
+            case 'prompts/list':
+                // Likewise — no prompts exposed, but answer the probe cleanly. (#621)
+                if (isRequest)
+                    this.transport.sendResult(message.id, { prompts: [] });
+                break;
+            default:
+                if (isRequest) {
+                    this.transport.sendError(message.id, transport_1.ErrorCodes.MethodNotFound, `Method not found: ${message.method}`);
+                }
+        }
+    }
+    async handleInitialize(request) {
+        const params = request.params;
+        this.clientSupportsRoots = !!params?.capabilities?.roots;
+        if (params?.clientInfo) {
+            this.clientInfo = {
+                name: typeof params.clientInfo.name === 'string' ? params.clientInfo.name : undefined,
+                version: typeof params.clientInfo.version === 'string' ? params.clientInfo.version : undefined,
+            };
+        }
+        // Explicit project signal, strongest first: client-provided rootUri /
+        // workspaceFolders (LSP-style), else the --path the server was launched
+        // with. cwd is NOT used here — we defer it so a roots/list answer can
+        // win over it. See issue #196.
+        let explicitPath = null;
+        if (params?.rootUri) {
+            explicitPath = fileUriToPath(params.rootUri);
+        }
+        else if (params?.workspaceFolders?.[0]?.uri) {
+            explicitPath = fileUriToPath(params.workspaceFolders[0].uri);
+        }
+        else if (this.explicitProjectPath) {
+            explicitPath = this.explicitProjectPath;
+        }
+        // Pick the instructions variant by the root's index state — a cheap
+        // synchronous walk-up (existsSync loop only, no DB open, so the #172
+        // respond-fast contract holds). When the root IS indexed, send the full
+        // single-project playbook. When it ISN'T, send the per-project variant
+        // (tools are still exposed — see handleToolsList): it tells the agent there
+        // is no default project and to pass `projectPath` to any project that has a
+        // `.bhgraph/`. Gating tool AVAILABILITY on whether `./` is indexed was the
+        // #964 bug — it broke monorepos (only sub-projects indexed) and never
+        // surfaced the tools after a mid-session `bhgraph init`. When no explicit
+        // path is known yet (roots/list dance pending), cwd is the best predictor of
+        // where the default project will resolve.
+        const indexed = (0, directory_1.findNearestBHGraphRoot)(explicitPath ?? process.cwd()) !== null;
+        // Respond to the handshake BEFORE doing any heavy init — see issue #172.
+        this.transport.sendResult(request.id, {
+            protocolVersion: exports.PROTOCOL_VERSION,
+            capabilities: { tools: {} },
+            serverInfo: exports.SERVER_INFO,
+            instructions: indexed ? server_instructions_1.SERVER_INSTRUCTIONS : server_instructions_1.SERVER_INSTRUCTIONS_NO_ROOT_INDEX,
+        });
+        if (explicitPath) {
+            // Kick off engine init in the background. If another session in the
+            // same daemon already opened the project, `ensureInitialized` is a
+            // ~free no-op — N concurrent clients pay exactly one open.
+            this.resolvePromise = this.engine.ensureInitialized(explicitPath);
+        }
+    }
+    async handleToolsList(request) {
+        await this.retryInitIfNeeded();
+        // Always expose the tools — even when the server root has no index. Gating
+        // availability on whether `./` is indexed (the old behavior) breaks the
+        // monorepo case where only sub-projects carry a `.bhgraph/` (the agent
+        // saw zero tools and couldn't even reach an indexed sub-project by
+        // `projectPath`), and it hides the tools from a session that started before
+        // the user ran `bhgraph init` (most hosts request the list once, so the
+        // freshly-built index never surfaces). #964. The not-indexed case is still
+        // safe: a call against an un-indexed path returns SUCCESS-shaped guidance
+        // ("pass projectPath / run bhgraph init"), never `isError`, so it can't
+        // teach the agent to abandon bhgraph. `getTools()` returns the default
+        // surface even before a project is open.
+        this.transport.sendResult(request.id, {
+            tools: this.engine.getToolHandler().getTools(),
+        });
+    }
+    async handleToolsCall(request) {
+        const params = request.params;
+        if (!params || !params.name) {
+            this.transport.sendError(request.id, transport_1.ErrorCodes.InvalidParams, 'Missing tool name');
+            return;
+        }
+        const toolName = params.name;
+        const toolArgs = params.arguments || {};
+        const tool = tools_1.tools.find((t) => t.name === toolName);
+        if (!tool) {
+            this.transport.sendError(request.id, transport_1.ErrorCodes.InvalidParams, `Unknown tool: ${toolName}`);
+            return;
+        }
+        await this.retryInitIfNeeded();
+        const result = await this.engine.getToolHandler().execute(toolName, toolArgs);
+        this.transport.sendResult(request.id, result);
+        // After the reply is on the wire — telemetry must never delay a tool
+        // response (in-memory increment only; see src/telemetry).
+        (0, telemetry_1.getTelemetry)().recordUsage('mcp_tool', toolName, !result.isError, this.clientInfo);
+    }
+    /**
+     * Lazy default-project resolution. Three layers:
+     *   1. await the in-flight init kicked off from `handleInitialize` (if any);
+     *   2. if still uninitialized and we never asked the client for its roots,
+     *      do so now (one-shot); fall back to cwd if the client lacks roots;
+     *   3. last-resort: re-walk from the best candidate — picks up projects
+     *      that were `bhgraph init`'d *after* the server started.
+     */
+    async retryInitIfNeeded() {
+        if (this.resolvePromise) {
+            try {
+                await this.resolvePromise;
+            }
+            catch { /* fall through to retry */ }
+            this.resolvePromise = null;
+        }
+        if (this.engine.hasDefaultBHGraph())
+            return;
+        const hint = this.explicitProjectPath ?? this.engine.getProjectPath();
+        if (!hint && !this.rootsAttempted) {
+            this.rootsAttempted = true;
+            this.resolvePromise = this.clientSupportsRoots
+                ? this.initFromRoots()
+                : this.engine.ensureInitialized(process.cwd());
+            try {
+                await this.resolvePromise;
+            }
+            catch { /* fall through */ }
+            this.resolvePromise = null;
+            if (this.engine.hasDefaultBHGraph())
+                return;
+        }
+        // Last resort: walk from the best candidate (sync open). Picks up
+        // projects that appeared after the server started.
+        const candidate = hint ?? process.cwd();
+        this.engine.retryInitializeSync(candidate);
+    }
+    /**
+     * Ask the client for its workspace root via `roots/list` and open the
+     * first one. Falls back to `process.cwd()` on timeout or empty answer.
+     */
+    async initFromRoots() {
+        let target = process.cwd();
+        try {
+            const result = await this.transport.request('roots/list', undefined, ROOTS_LIST_TIMEOUT_MS);
+            const rootPath = firstRootPath(result);
+            if (rootPath) {
+                target = rootPath;
+            }
+            else {
+                process.stderr.write('[BHGraph MCP] Client returned no workspace roots; falling back to process cwd.\n');
+            }
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            process.stderr.write(`[BHGraph MCP] roots/list request failed (${msg}); falling back to process cwd.\n`);
+        }
+        await this.engine.ensureInitialized(target);
+    }
+}
+exports.MCPSession = MCPSession;
+//# sourceMappingURL=session.js.map

package/lib/dist/mcp/session.js.map

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

package/lib/dist/mcp/startup-handshake.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Never-initialized backstop for `serve --mcp` (#1185).
+ *
+ * Every real MCP host sends `initialize` immediately after spawning a server.
+ * A server that has received NO bytes at all for many minutes is not serving
+ * anyone — it is the residue of an abandoned launch: the host killed the
+ * launcher chain during startup (config probe, instant cancel, initialize
+ * timeout) but kept our stdio pipe fds open, so stdin never EOFs. If the kill
+ * landed before {@link ../mcp/early-ppid} could observe the real parent, the
+ * PPID watchdog is blind too (baseline `1`), and — pre-#1185 — the orphan
+ * lived until the HOST process exited, accumulating one ~30MB node process
+ * per occurrence.
+ *
+ * This backstop closes that last hole: arm a one-shot timer at serve start
+ * and disarm it on the first byte of client traffic. If the timer fires, the
+ * caller shuts the server down. The default is deliberately generous (15
+ * minutes) — hosts initialize within milliseconds, so the only processes this
+ * ever reaps are ones nobody is talking to. It never affects a session that
+ * spoke even once: after the first byte the timer is gone for good (a
+ * quiet-but-live session is the PPID watchdog's / stdin teardown's job).
+ *
+ * IMPORTANT (callers): attaching a `'data'` listener switches the stream into
+ * flowing mode. Arm this AFTER the real stdin consumer is attached, in the
+ * same synchronous block, so no early bytes are emitted while only our
+ * listener exists. The detached daemon must never arm this — its stdin is
+ * `'ignore'` and its lifecycle is refcount/idle-based.
+ *
+ * Tune with `BHGRAPH_STARTUP_HANDSHAKE_TIMEOUT_MS`; `0` disables.
+ */
+/** Default wait for the first byte of MCP traffic before assuming orphaned. */
+export declare const DEFAULT_STARTUP_HANDSHAKE_TIMEOUT_MS = 900000;
+export declare const STARTUP_HANDSHAKE_TIMEOUT_ENV = "BHGRAPH_STARTUP_HANDSHAKE_TIMEOUT_MS";
+/**
+ * Parse the timeout env override. Missing/invalid → default; `<= 0` → `0`
+ * (disabled), the same disable convention as `BHGRAPH_PPID_POLL_MS`.
+ */
+export declare function parseStartupHandshakeTimeoutMs(raw: string | undefined): number;
+/**
+ * Arm the backstop. `onAbandoned` runs at most once, only if no `'data'` event
+ * arrives on `stream` within the timeout. Returns a disarm function (idempotent;
+ * also detaches the listener). `stream`/`timeoutMs` are injectable for tests.
+ */
+export declare function armStartupHandshakeTimeout(onAbandoned: () => void, stream?: NodeJS.ReadableStream, timeoutMs?: number): () => void;
+//# sourceMappingURL=startup-handshake.d.ts.map

package/lib/dist/mcp/startup-handshake.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"startup-handshake.d.ts","sourceRoot":"","sources":["../../src/mcp/startup-handshake.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,+EAA+E;AAC/E,eAAO,MAAM,oCAAoC,SAAU,CAAC;AAE5D,eAAO,MAAM,6BAA6B,yCAAyC,CAAC;AAEpF;;;GAGG;AACH,wBAAgB,8BAA8B,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAM9E;AAED;;;;GAIG;AACH,wBAAgB,0BAA0B,CACxC,WAAW,EAAE,MAAM,IAAI,EACvB,MAAM,GAAE,MAAM,CAAC,cAA8B,EAC7C,SAAS,GAAE,MAAmF,GAC7F,MAAM,IAAI,CAcZ"}

package/lib/dist/mcp/startup-handshake.js

@@ -0,0 +1,73 @@
+"use strict";
+/**
+ * Never-initialized backstop for `serve --mcp` (#1185).
+ *
+ * Every real MCP host sends `initialize` immediately after spawning a server.
+ * A server that has received NO bytes at all for many minutes is not serving
+ * anyone — it is the residue of an abandoned launch: the host killed the
+ * launcher chain during startup (config probe, instant cancel, initialize
+ * timeout) but kept our stdio pipe fds open, so stdin never EOFs. If the kill
+ * landed before {@link ../mcp/early-ppid} could observe the real parent, the
+ * PPID watchdog is blind too (baseline `1`), and — pre-#1185 — the orphan
+ * lived until the HOST process exited, accumulating one ~30MB node process
+ * per occurrence.
+ *
+ * This backstop closes that last hole: arm a one-shot timer at serve start
+ * and disarm it on the first byte of client traffic. If the timer fires, the
+ * caller shuts the server down. The default is deliberately generous (15
+ * minutes) — hosts initialize within milliseconds, so the only processes this
+ * ever reaps are ones nobody is talking to. It never affects a session that
+ * spoke even once: after the first byte the timer is gone for good (a
+ * quiet-but-live session is the PPID watchdog's / stdin teardown's job).
+ *
+ * IMPORTANT (callers): attaching a `'data'` listener switches the stream into
+ * flowing mode. Arm this AFTER the real stdin consumer is attached, in the
+ * same synchronous block, so no early bytes are emitted while only our
+ * listener exists. The detached daemon must never arm this — its stdin is
+ * `'ignore'` and its lifecycle is refcount/idle-based.
+ *
+ * Tune with `BHGRAPH_STARTUP_HANDSHAKE_TIMEOUT_MS`; `0` disables.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STARTUP_HANDSHAKE_TIMEOUT_ENV = exports.DEFAULT_STARTUP_HANDSHAKE_TIMEOUT_MS = void 0;
+exports.parseStartupHandshakeTimeoutMs = parseStartupHandshakeTimeoutMs;
+exports.armStartupHandshakeTimeout = armStartupHandshakeTimeout;
+/** Default wait for the first byte of MCP traffic before assuming orphaned. */
+exports.DEFAULT_STARTUP_HANDSHAKE_TIMEOUT_MS = 900_000; // 15 min
+exports.STARTUP_HANDSHAKE_TIMEOUT_ENV = 'BHGRAPH_STARTUP_HANDSHAKE_TIMEOUT_MS';
+/**
+ * Parse the timeout env override. Missing/invalid → default; `<= 0` → `0`
+ * (disabled), the same disable convention as `BHGRAPH_PPID_POLL_MS`.
+ */
+function parseStartupHandshakeTimeoutMs(raw) {
+    if (raw === undefined || raw === '')
+        return exports.DEFAULT_STARTUP_HANDSHAKE_TIMEOUT_MS;
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed))
+        return exports.DEFAULT_STARTUP_HANDSHAKE_TIMEOUT_MS;
+    if (parsed <= 0)
+        return 0;
+    return Math.floor(parsed);
+}
+/**
+ * Arm the backstop. `onAbandoned` runs at most once, only if no `'data'` event
+ * arrives on `stream` within the timeout. Returns a disarm function (idempotent;
+ * also detaches the listener). `stream`/`timeoutMs` are injectable for tests.
+ */
+function armStartupHandshakeTimeout(onAbandoned, stream = process.stdin, timeoutMs = parseStartupHandshakeTimeoutMs(process.env[exports.STARTUP_HANDSHAKE_TIMEOUT_ENV])) {
+    if (timeoutMs <= 0)
+        return () => { };
+    const onFirstData = () => { clearTimeout(timer); };
+    const timer = setTimeout(() => {
+        stream.removeListener('data', onFirstData);
+        onAbandoned();
+    }, timeoutMs);
+    // Never let the backstop itself keep an otherwise-finished process alive.
+    timer.unref?.();
+    stream.once('data', onFirstData);
+    return () => {
+        stream.removeListener('data', onFirstData);
+        clearTimeout(timer);
+    };
+}
+//# sourceMappingURL=startup-handshake.js.map