@colbymchenry/codegraph-win32-arm64 0.9.9 → 1.0.1

package/lib/dist/mcp/liveness-watchdog.js

@@ -0,0 +1,207 @@
+"use strict";
+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.DEFAULT_WATCHDOG_TIMEOUT_MS = void 0;
+exports.parseWatchdogTimeoutMs = parseWatchdogTimeoutMs;
+exports.deriveCheckIntervalMs = deriveCheckIntervalMs;
+exports.installMainThreadWatchdog = installMainThreadWatchdog;
+/**
+ * Main-thread liveness watchdog — belt-and-suspenders for #850.
+ *
+ * The #850 fix removes the one *known* trigger (the uncaught-exception handler
+ * no longer formats a raw Error's `.stack`). But ANY synchronous, non-yielding
+ * loop on the main thread — a future V8 stack-format pathology, a runaway
+ * regex, an accidental `while (true)` — wedges the event loop, and from JS you
+ * cannot interrupt it: timers, signal handlers, and the PPID watchdog all run
+ * *on* that blocked loop, so the process pins a core forever with no
+ * self-recovery (the exact unrecoverable state #850 reported).
+ *
+ * **Why a separate PROCESS, not a worker thread.** A worker thread was the
+ * obvious first choice and it works in a toy process — but it was validated to
+ * FAIL in the real daemon (#850 live test). V8 isolates in one process
+ * coordinate on global safepoints, so when one thread requests a GC every other
+ * thread must reach a safepoint before it can proceed. A main thread wedged in
+ * a tight, non-allocating loop never reaches one, which strands the watchdog
+ * worker on its very next allocation/safepoint check — and the #850 hot loop
+ * (`SourcePositionTableIterator::Advance`, a non-allocating C++ table walk) is
+ * exactly that shape. A child process shares no isolate and no heap with the
+ * parent, so the wedge cannot touch it; it kills via the kernel, which honours
+ * SIGKILL regardless of what the parent's threads are doing.
+ *
+ * **How.** The parent writes a heartbeat byte to the child's stdin every
+ * `checkMs` from a timer — firing at all means the event loop is turning. The
+ * child resets a kill-timer on each byte; if none arrives for `timeoutMs` it
+ * `SIGKILL`s the parent so a fresh daemon starts on the next connection. When
+ * the parent exits normally the pipe closes and the child exits too (no
+ * orphan).
+ *
+ * **Won't fire on real work.** Heavy parsing runs in the parse worker
+ * (off-thread) and indexing shells out to a child process, so the daemon's main
+ * thread only ever does fast, bounded work. The default timeout is ~300× the
+ * 5h #850 wedge shorter, yet far longer than any legitimate main-thread block.
+ * Opt out with `CODEGRAPH_NO_WATCHDOG=1`; tune with `CODEGRAPH_WATCHDOG_TIMEOUT_MS`.
+ */
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const child_process_1 = require("child_process");
+/** Default: 60s — ~300× shorter than the 5h #850 wedge, far longer than any real main-thread block. */
+exports.DEFAULT_WATCHDOG_TIMEOUT_MS = 60_000;
+/** `true` for `1/true/yes/on` (case-insensitive); `false` otherwise. */
+function isEnvTruthy(raw) {
+    if (!raw)
+        return false;
+    return ['1', 'true', 'yes', 'on'].includes(raw.trim().toLowerCase());
+}
+/** Parse the timeout env, falling back to the default for missing/invalid values. */
+function parseWatchdogTimeoutMs(raw, fallback = exports.DEFAULT_WATCHDOG_TIMEOUT_MS) {
+    if (raw === undefined)
+        return fallback;
+    const n = Number(raw);
+    return Number.isFinite(n) && n > 0 ? n : fallback;
+}
+/** Derive a heartbeat cadence that emits several beats inside the timeout window. */
+function deriveCheckIntervalMs(timeoutMs) {
+    return Math.min(2000, Math.max(50, Math.round(timeoutMs / 5)));
+}
+/** Arming/teardown diagnostics, gated on the existing MCP debug switch. */
+function debug(msg) {
+    if (process.env.CODEGRAPH_MCP_DEBUG) {
+        try {
+            fs.writeSync(2, `[CodeGraph watchdog] ${msg}\n`);
+        }
+        catch { /* ignore */ }
+    }
+}
+/**
+ * The watchdog child body, run via `node -e`. Inlined as a string (not a
+ * shipped `.js`) so there is no dist-vs-src path to resolve — it runs
+ * identically under `tsx` in tests and under the bundle in production. Reads its
+ * target pid + timeout from argv; an MSG built once at startup (the child is
+ * never wedged, so allocation here is fine).
+ */
+const CHILD_SOURCE = `
+const fs = require('fs');
+const parentPid = Number(process.argv[1]);
+const timeoutMs = Number(process.argv[2]);
+const secs = Math.round(timeoutMs / 1000);
+const MSG = Buffer.from('[CodeGraph] Main thread unresponsive for ~' + secs + 's — killing the wedged process so a fresh one can start (#850). Disable with CODEGRAPH_NO_WATCHDOG=1.\\n');
+function kill() {
+  try { fs.writeSync(2, MSG); } catch (e) {}
+  try { process.kill(parentPid, 'SIGKILL'); } catch (e) {}
+  process.exit(0);
+}
+let timer = setTimeout(kill, timeoutMs);
+process.stdin.on('data', () => { clearTimeout(timer); timer = setTimeout(kill, timeoutMs); });
+process.stdin.on('end', () => process.exit(0));   // parent closed the pipe (exited) -> no orphan
+process.stdin.on('error', () => process.exit(0)); // pipe broke -> parent gone
+process.stdin.resume();
+`;
+/**
+ * Install the main-thread liveness watchdog for a long-lived process. Returns a
+ * handle to stop it, or `null` when disabled or when the child can't be spawned
+ * (degraded, never throws — a missing watchdog must never keep a process from
+ * starting).
+ */
+function installMainThreadWatchdog() {
+    if (isEnvTruthy(process.env.CODEGRAPH_NO_WATCHDOG))
+        return null;
+    const timeoutMs = parseWatchdogTimeoutMs(process.env.CODEGRAPH_WATCHDOG_TIMEOUT_MS);
+    const checkMs = deriveCheckIntervalMs(timeoutMs);
+    let child;
+    try {
+        // No execArgv inheritance (unlike Worker), so the child carries none of our
+        // V8 flags — it runs no WASM and needs none. stderr inherits the parent's
+        // fd 2 so the kill notice lands wherever the parent logs (daemon.log).
+        child = (0, child_process_1.spawn)(process.execPath, ['-e', CHILD_SOURCE, String(process.pid), String(timeoutMs)], {
+            stdio: ['pipe', 'ignore', 'inherit'],
+            windowsHide: true,
+            // The watchdog touches no files; keep its cwd off the project/temp dir
+            // so it can't hold one open (Windows EPERM-on-cleanup, mirrors the
+            // parse-worker quirk).
+            cwd: os.tmpdir(),
+        });
+    }
+    catch (err) {
+        debug(`spawn failed: ${err instanceof Error ? err.message : String(err)}`);
+        return null;
+    }
+    const stdin = child.stdin;
+    if (!stdin) {
+        debug('child has no stdin pipe; not arming');
+        try {
+            child.kill();
+        }
+        catch { /* ignore */ }
+        return null;
+    }
+    // Writing after the child exits surfaces EPIPE on the stream — swallow it so
+    // it can't escalate to the global handler (which now exits, #850).
+    stdin.on('error', () => { });
+    child.on('error', (err) => debug(`child error: ${err.message}`));
+    // Heartbeat: a byte per tick. When the main thread wedges, these stop and the
+    // child's timeout fires. unref'd so it never keeps the process alive itself.
+    const heartbeat = setInterval(() => {
+        try {
+            stdin.write('\n');
+        }
+        catch { /* child gone */ }
+    }, checkMs);
+    heartbeat.unref();
+    // Neither the child nor its pipe should keep the parent alive past its work.
+    child.unref();
+    try {
+        stdin.unref?.();
+    }
+    catch { /* ignore */ }
+    debug(`armed (child pid ${child.pid ?? '?'}): timeoutMs=${timeoutMs} checkMs=${checkMs}`);
+    let stopped = false;
+    return {
+        stop() {
+            if (stopped)
+                return;
+            stopped = true;
+            clearInterval(heartbeat);
+            try {
+                stdin.end();
+            }
+            catch { /* ignore */ } // EOF -> child exits cleanly
+            try {
+                child.kill();
+            }
+            catch { /* ignore */ } // belt-and-suspenders
+        },
+    };
+}
+//# sourceMappingURL=liveness-watchdog.js.map

package/lib/dist/mcp/liveness-watchdog.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"liveness-watchdog.js","sourceRoot":"","sources":["../../src/mcp/liveness-watchdog.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkDA,wDAOC;AAGD,sDAEC;AA6CD,8DA8DC;AAzKD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,uCAAyB;AACzB,uCAAyB;AACzB,iDAAoD;AAEpD,uGAAuG;AAC1F,QAAA,2BAA2B,GAAG,MAAM,CAAC;AAElD,wEAAwE;AACxE,SAAS,WAAW,CAAC,GAAuB;IAC1C,IAAI,CAAC,GAAG;QAAE,OAAO,KAAK,CAAC;IACvB,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC,CAAC;AACvE,CAAC;AAED,qFAAqF;AACrF,SAAgB,sBAAsB,CACpC,GAAuB,EACvB,WAAmB,mCAA2B;IAE9C,IAAI,GAAG,KAAK,SAAS;QAAE,OAAO,QAAQ,CAAC;IACvC,MAAM,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;IACtB,OAAO,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC;AACpD,CAAC;AAED,qFAAqF;AACrF,SAAgB,qBAAqB,CAAC,SAAiB;IACrD,OAAO,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,IAAI,CAAC,KAAK,CAAC,SAAS,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;AACjE,CAAC;AAED,2EAA2E;AAC3E,SAAS,KAAK,CAAC,GAAW;IACxB,IAAI,OAAO,CAAC,GAAG,CAAC,mBAAmB,EAAE,CAAC;QACpC,IAAI,CAAC;YAAC,EAAE,CAAC,SAAS,CAAC,CAAC,EAAE,wBAAwB,GAAG,IAAI,CAAC,CAAC;QAAC,CAAC;QAAC,MAAM,CAAC,CAAC,YAAY,CAAC,CAAC;IAClF,CAAC;AACH,CAAC;AAOD;;;;;;GAMG;AACH,MAAM,YAAY,GAAG;;;;;;;;;;;;;;;;CAgBpB,CAAC;AAEF;;;;;GAKG;AACH,SAAgB,yBAAyB;IACvC,IAAI,WAAW,CAAC,OAAO,CAAC,GAAG,CAAC,qBAAqB,CAAC;QAAE,OAAO,IAAI,CAAC;IAEhE,MAAM,SAAS,GAAG,sBAAsB,CAAC,OAAO,CAAC,GAAG,CAAC,6BAA6B,CAAC,CAAC;IACpF,MAAM,OAAO,GAAG,qBAAqB,CAAC,SAAS,CAAC,CAAC;IAEjD,IAAI,KAAmB,CAAC;IACxB,IAAI,CAAC;QACH,4EAA4E;QAC5E,0EAA0E;QAC1E,uEAAuE;QACvE,KAAK,GAAG,IAAA,qBAAK,EACX,OAAO,CAAC,QAAQ,EAChB,CAAC,IAAI,EAAE,YAAY,EAAE,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC,SAAS,CAAC,CAAC,EAC5D;YACE,KAAK,EAAE,CAAC,MAAM,EAAE,QAAQ,EAAE,SAAS,CAAC;YACpC,WAAW,EAAE,IAAI;YACjB,uEAAuE;YACvE,mEAAmE;YACnE,uBAAuB;YACvB,GAAG,EAAE,EAAE,CAAC,MAAM,EAAE;SACjB,CACF,CAAC;IACJ,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,KAAK,CAAC,iBAAiB,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QAC3E,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC;IAC1B,IAAI,CAAC,KAAK,EAAE,CAAC;QACX,KAAK,CAAC,qCAAqC,CAAC,CAAC;QAC7C,IAAI,CAAC;YAAC,KAAK,CAAC,IAAI,EAAE,CAAC;QAAC,CAAC;QAAC,MAAM,CAAC,CAAC,YAAY,CAAC,CAAC;QAC5C,OAAO,IAAI,CAAC;IACd,CAAC;IACD,6EAA6E;IAC7E,mEAAmE;IACnE,KAAK,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,EAAE,GAAsD,CAAC,CAAC,CAAC;IAChF,KAAK,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,KAAK,CAAC,gBAAgB,GAAG,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;IAEjE,8EAA8E;IAC9E,6EAA6E;IAC7E,MAAM,SAAS,GAAG,WAAW,CAAC,GAAG,EAAE;QACjC,IAAI,CAAC;YAAC,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QAAC,CAAC;QAAC,MAAM,CAAC,CAAC,gBAAgB,CAAC,CAAC;IACvD,CAAC,EAAE,OAAO,CAAC,CAAC;IACZ,SAAS,CAAC,KAAK,EAAE,CAAC;IAElB,6EAA6E;IAC7E,KAAK,CAAC,KAAK,EAAE,CAAC;IACd,IAAI,CAAC;QAAE,KAA2C,CAAC,KAAK,EAAE,EAAE,CAAC;IAAC,CAAC;IAAC,MAAM,CAAC,CAAC,YAAY,CAAC,CAAC;IAEtF,KAAK,CAAC,oBAAoB,KAAK,CAAC,GAAG,IAAI,GAAG,gBAAgB,SAAS,YAAY,OAAO,EAAE,CAAC,CAAC;IAE1F,IAAI,OAAO,GAAG,KAAK,CAAC;IACpB,OAAO;QACL,IAAI;YACF,IAAI,OAAO;gBAAE,OAAO;YACpB,OAAO,GAAG,IAAI,CAAC;YACf,aAAa,CAAC,SAAS,CAAC,CAAC;YACzB,IAAI,CAAC;gBAAC,KAAK,CAAC,GAAG,EAAE,CAAC;YAAC,CAAC;YAAC,MAAM,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,6BAA6B;YACzE,IAAI,CAAC;gBAAC,KAAK,CAAC,IAAI,EAAE,CAAC;YAAC,CAAC;YAAC,MAAM,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,sBAAsB;QACrE,CAAC;KACF,CAAC;AACJ,CAAC"}

package/lib/dist/mcp/ppid-watchdog.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Shared decision logic for the PPID watchdog (#277, #692).
+ *
+ * The watchdog's job: notice that the process we depend on — our parent, or the
+ * MCP host reached past an intermediate launcher — has died, so an orphaned
+ * proxy / direct server shuts itself down instead of leaking forever.
+ *
+ * Parent death surfaces differently per OS, and getting this wrong is what
+ * caused the unbounded daemon/proxy leak on Windows (#692, #576):
+ *
+ *   - **POSIX** reparents an orphan to init (pid 1), so `process.ppid` *changes*
+ *     the instant the parent dies. That divergence is the classic #277 signal.
+ *   - **Windows** never reparents: `process.ppid` keeps reporting the original
+ *     (now-dead) parent forever, so the change-check can never fire. There we
+ *     must poll the original parent's *liveness* instead.
+ *
+ * The liveness fallback is deliberately gated to Windows. On POSIX a
+ * double-forked grandparent can legitimately outlive the reparent, so a dead
+ * `originalPpid` is not proof of orphaning there — the change-check is the
+ * correct and sufficient POSIX signal, and using liveness too would risk a
+ * false-positive shutdown.
+ */
+export interface SupervisionState {
+    /** `process.ppid` captured at startup. */
+    originalPpid: number;
+    /** `process.ppid` right now. */
+    currentPpid: number;
+    /**
+     * The MCP host pid threaded past an intermediate launcher
+     * (`CODEGRAPH_HOST_PPID`), or null when unknown — e.g. the standalone bundle,
+     * which pre-bakes `--liftoff-only` and so never runs the relaunch that sets it.
+     */
+    hostPpid: number | null;
+    /** Liveness probe — `process.kill(pid, 0)` in production, stubbed in tests. */
+    isAlive: (pid: number) => boolean;
+    /** Defaults to `process.platform`. */
+    platform?: NodeJS.Platform;
+}
+/**
+ * Returns a human-readable reason string when the process has lost its
+ * supervisor and should shut down, or null while it is still supervised.
+ */
+export declare function supervisionLostReason(state: SupervisionState): string | null;
+//# sourceMappingURL=ppid-watchdog.d.ts.map

package/lib/dist/mcp/ppid-watchdog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ppid-watchdog.d.ts","sourceRoot":"","sources":["../../src/mcp/ppid-watchdog.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,WAAW,gBAAgB;IAC/B,0CAA0C;IAC1C,YAAY,EAAE,MAAM,CAAC;IACrB,gCAAgC;IAChC,WAAW,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,+EAA+E;IAC/E,OAAO,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC;IAClC,sCAAsC;IACtC,QAAQ,CAAC,EAAE,MAAM,CAAC,QAAQ,CAAC;CAC5B;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,gBAAgB,GAAG,MAAM,GAAG,IAAI,CAmB5E"}

package/lib/dist/mcp/ppid-watchdog.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.supervisionLostReason = supervisionLostReason;
+/**
+ * Returns a human-readable reason string when the process has lost its
+ * supervisor and should shut down, or null while it is still supervised.
+ */
+function supervisionLostReason(state) {
+    const { originalPpid, currentPpid, hostPpid, isAlive } = state;
+    const platform = state.platform ?? process.platform;
+    // POSIX: the parent dying reparents us, so ppid diverges. (Never on Windows.)
+    if (currentPpid !== originalPpid) {
+        return `ppid ${originalPpid} -> ${currentPpid}`;
+    }
+    // Windows: ppid is stable across parent death, so detect it by liveness.
+    // Skip pid 0/1 — "unknown" and init are never a real Windows parent, and a
+    // bogus liveness probe there must not trigger a shutdown.
+    if (platform === 'win32' && originalPpid > 1 && !isAlive(originalPpid)) {
+        return `parent pid ${originalPpid} exited`;
+    }
+    // Either platform: the host pid threaded past a launcher shim is gone.
+    if (hostPpid !== null && !isAlive(hostPpid)) {
+        return `host pid ${hostPpid} exited`;
+    }
+    return null;
+}
+//# sourceMappingURL=ppid-watchdog.js.map

package/lib/dist/mcp/ppid-watchdog.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ppid-watchdog.js","sourceRoot":"","sources":["../../src/mcp/ppid-watchdog.ts"],"names":[],"mappings":";;AA2CA,sDAmBC;AAvBD;;;GAGG;AACH,SAAgB,qBAAqB,CAAC,KAAuB;IAC3D,MAAM,EAAE,YAAY,EAAE,WAAW,EAAE,QAAQ,EAAE,OAAO,EAAE,GAAG,KAAK,CAAC;IAC/D,MAAM,QAAQ,GAAG,KAAK,CAAC,QAAQ,IAAI,OAAO,CAAC,QAAQ,CAAC;IAEpD,8EAA8E;IAC9E,IAAI,WAAW,KAAK,YAAY,EAAE,CAAC;QACjC,OAAO,QAAQ,YAAY,OAAO,WAAW,EAAE,CAAC;IAClD,CAAC;IACD,yEAAyE;IACzE,2EAA2E;IAC3E,0DAA0D;IAC1D,IAAI,QAAQ,KAAK,OAAO,IAAI,YAAY,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,EAAE,CAAC;QACvE,OAAO,cAAc,YAAY,SAAS,CAAC;IAC7C,CAAC;IACD,uEAAuE;IACvE,IAAI,QAAQ,KAAK,IAAI,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC5C,OAAO,YAAY,QAAQ,SAAS,CAAC;IACvC,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC"}

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

@@ -18,7 +18,13 @@
  *     the direct-mode server uses; see issue #277.
  */
 import * as net from 'net';
+import { DaemonHello } from './daemon';
 import type { MCPEngine } from './engine';
+/**
+ * Log a successful daemon attach — gated behind {@link LOG_ATTACH_ENV} so it is
+ * silent by default (see #618). Exported for tests.
+ */
+export declare function logAttachedDaemon(socketPath: string, hello: DaemonHello): void;
 export interface ProxyResult {
     /**
      * `proxied` — successfully attached to a same-version daemon and piped

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

@@ -1 +1 @@
-{"version":3,"file":"proxy.d.ts","sourceRoot":"","sources":["../../src/mcp/proxy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAGH,OAAO,KAAK,GAAG,MAAM,KAAK,CAAC;AAO3B,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAK1C,MAAM,WAAW,WAAW;IAC1B;;;;;OAKG;IACH,OAAO,EAAE,SAAS,GAAG,iBAAiB,CAAC;IACvC,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,QAAQ,CAC5B,UAAU,EAAE,MAAM,EAClB,eAAe,GAAE,MAAgC,GAChD,OAAO,CAAC,WAAW,CAAC,CAsCtB;AAED;;;;;GAKG;AACH,wBAAsB,gBAAgB,CACpC,UAAU,EAAE,MAAM,EAClB,eAAe,GAAE,MAAgC,GAChD,OAAO,CAAC,GAAG,CAAC,MAAM,GAAG,kBAAkB,GAAG,IAAI,CAAC,CAuBjD;AAID;+DAC+D;AAC/D,MAAM,WAAW,kBAAkB;IACjC;yFACqF;IACrF,eAAe,IAAI,OAAO,CAAC,GAAG,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IAC9C;6EACyE;IACzE,UAAU,IAAI,SAAS,CAAC;IACxB,wDAAwD;IACxD,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,sBAAsB,CAAC,IAAI,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CA+GpF"}
+{"version":3,"file":"proxy.d.ts","sourceRoot":"","sources":["../../src/mcp/proxy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAGH,OAAO,KAAK,GAAG,MAAM,KAAK,CAAC;AAE3B,OAAO,EAAqB,WAAW,EAAwB,MAAM,UAAU,CAAC;AAQhF,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAc1C;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,WAAW,GAAG,IAAI,CAK9E;AAED,MAAM,WAAW,WAAW;IAC1B;;;;;OAKG;IACH,OAAO,EAAE,SAAS,GAAG,iBAAiB,CAAC;IACvC,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,QAAQ,CAC5B,UAAU,EAAE,MAAM,EAClB,eAAe,GAAE,MAAgC,GAChD,OAAO,CAAC,WAAW,CAAC,CAqCtB;AAED;;;;;GAKG;AACH,wBAAsB,gBAAgB,CACpC,UAAU,EAAE,MAAM,EAClB,eAAe,GAAE,MAAgC,GAChD,OAAO,CAAC,GAAG,CAAC,MAAM,GAAG,kBAAkB,GAAG,IAAI,CAAC,CAsBjD;AAsBD;+DAC+D;AAC/D,MAAM,WAAW,kBAAkB;IACjC;yFACqF;IACrF,eAAe,IAAI,OAAO,CAAC,GAAG,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IAC9C;6EACyE;IACzE,UAAU,IAAI,SAAS,CAAC;IACxB,wDAAwD;IACxD,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,sBAAsB,CAAC,IAAI,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CA8KpF"}

package/lib/dist/mcp/proxy.js

@@ -52,6 +52,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.logAttachedDaemon = logAttachedDaemon;
 exports.runProxy = runProxy;
 exports.connectWithHello = connectWithHello;
 exports.runLocalHandshakeProxy = runLocalHandshakeProxy;
@@ -59,12 +60,32 @@ const fs = __importStar(require("fs"));
 const net = __importStar(require("net"));
 const wasm_runtime_flags_1 = require("../extraction/wasm-runtime-flags");
 const daemon_1 = require("./daemon");
+const ppid_watchdog_1 = require("./ppid-watchdog");
+const stdin_teardown_1 = require("./stdin-teardown");
 const version_1 = require("./version");
 const session_1 = require("./session");
 const server_instructions_1 = require("./server-instructions");
 const tools_1 = require("./tools");
+const telemetry_1 = require("../telemetry");
 /** Default poll cadence for the PPID watchdog (same as the direct server). */
 const DEFAULT_PPID_POLL_MS = 5000;
+/**
+ * Env var that opts INTO the "attached to shared daemon" log line. Off by
+ * default: the line is benign INFO, but MCP hosts render any server stderr at
+ * error level (and append an `undefined` data field), so on every session start
+ * a healthy attach showed up as `[error] … undefined`. Set to `1` to surface it
+ * when debugging daemon attach. (#618; approach from #640 by @mturac)
+ */
+const LOG_ATTACH_ENV = 'CODEGRAPH_MCP_LOG_ATTACH';
+/**
+ * Log a successful daemon attach — gated behind {@link LOG_ATTACH_ENV} so it is
+ * silent by default (see #618). Exported for tests.
+ */
+function logAttachedDaemon(socketPath, hello) {
+    if (process.env[LOG_ATTACH_ENV] !== '1')
+        return;
+    process.stderr.write(`[CodeGraph MCP] Attached to shared daemon on ${socketPath} (pid ${hello.pid}, v${hello.codegraph}).\n`);
+}
 /**
  * Attempt to connect to the daemon at `socketPath` and pipe stdio through it.
  *
@@ -102,7 +123,8 @@ async function runProxy(socketPath, expectedVersion = version_1.CodeGraphPackage
         socket.destroy();
         return { outcome: 'fallback-needed', reason: 'version mismatch' };
     }
-    process.stderr.write(`[CodeGraph MCP] Attached to shared daemon on ${socketPath} (pid ${hello.pid}, v${hello.codegraph}).\n`);
+    logAttachedDaemon(socketPath, hello);
+    sendClientHello(socket);
     startPpidWatchdog(socket);
     await pipeUntilClose(socket);
     // Host disconnected (or the daemon went away). The proxy's only job is the
@@ -134,9 +156,30 @@ async function connectWithHello(socketPath, expectedVersion = version_1.CodeGrap
         socket.destroy();
         return 'version-mismatch';
     }
-    process.stderr.write(`[CodeGraph MCP] Attached to shared daemon on ${socketPath} (pid ${hello.pid}, v${hello.codegraph}).\n`);
+    logAttachedDaemon(socketPath, hello);
+    sendClientHello(socket);
     return socket;
 }
+/**
+ * Tell the daemon our pids right after we verify its hello, so its liveness
+ * sweep can reap this client if our process dies without the socket ever
+ * signalling close (the Windows named-pipe hazard behind #692). Best-effort:
+ * sent before any piped bytes so it's always the daemon's first line from us,
+ * and a write failure here is harmless (the daemon just falls back to the
+ * socket-close lifecycle). `hostPid` mirrors the PPID watchdog: the threaded
+ * host pid if set, else our own parent (the host, on a no-relaunch bundle).
+ */
+function sendClientHello(socket) {
+    const clientHello = {
+        codegraph_client: 1,
+        pid: process.pid,
+        hostPid: parseHostPpid(process.env[wasm_runtime_flags_1.HOST_PPID_ENV]) ?? process.ppid,
+    };
+    try {
+        socket.write(JSON.stringify(clientHello) + '\n');
+    }
+    catch { /* best-effort */ }
+}
 /**
  * Local-handshake proxy (the cold-start fix).
  *
@@ -154,10 +197,28 @@ async function runLocalHandshakeProxy(deps) {
     let daemonStatus = 'connecting';
     let daemonSocket = null;
     let clientInitId = undefined; // suppress the daemon's reply to the forwarded initialize
+    // Telemetry attribution for the in-process fallback only — calls routed to
+    // the daemon are counted by the daemon's own session (which receives the
+    // forwarded initialize, clientInfo included), never double-counted here.
+    let telemetryClient;
     const pending = []; // client lines buffered until the daemon resolves
     let engine = null;
     let engineReady = null;
     let shuttingDown = false;
+    // Requests forwarded to the daemon and not yet answered, keyed by JSON-RPC id.
+    // If the daemon dies mid-session (#662 — e.g. an MCP host SIGTERM's it when a
+    // new session starts), these would otherwise hang forever; we re-serve them
+    // in-process so the host always gets a reply.
+    const inflight = new Map();
+    const trackInflight = (line) => {
+        try {
+            const m = JSON.parse(line);
+            if (m && m.id !== undefined && typeof m.method === 'string' && m.method !== 'initialize') {
+                inflight.set(m.id, line);
+            }
+        }
+        catch { /* unparseable — nothing we could re-serve anyway */ }
+    };
     const writeClient = (obj) => {
         try {
             process.stdout.write((typeof obj === 'string' ? obj : JSON.stringify(obj)) + '\n');
@@ -201,6 +262,7 @@ async function runLocalHandshakeProxy(deps) {
                 const params = (msg.params || {});
                 const result = await engine.getToolHandler().execute(params.name, params.arguments || {});
                 writeClient({ jsonrpc: '2.0', id, result });
+                (0, telemetry_1.getTelemetry)().recordUsage('mcp_tool', params.name, !result.isError, telemetryClient);
             }
             catch (err) {
                 writeClient({ jsonrpc: '2.0', id, error: { code: -32603, message: err instanceof Error ? err.message : String(err) } });
@@ -209,10 +271,16 @@ async function runLocalHandshakeProxy(deps) {
         else if (msg.method === 'ping' && id !== undefined) {
             writeClient({ jsonrpc: '2.0', id, result: {} });
         }
+        else if (id !== undefined && msg.method !== 'initialize') {
+            // A request we can't serve in-process (and the daemon is gone) — answer
+            // with an error rather than let the host hang on a reply that won't come.
+            writeClient({ jsonrpc: '2.0', id, error: { code: -32603, message: 'CodeGraph daemon unavailable' } });
+        }
         // initialize already answered locally; notifications (initialized) need no reply.
     };
     const routeToDaemon = (line) => {
         if (daemonStatus === 'ready' && daemonSocket) {
+            trackInflight(line);
             try {
                 daemonSocket.write(line.endsWith('\n') ? line : line + '\n');
             }
@@ -246,19 +314,40 @@ async function runLocalHandshakeProxy(deps) {
             }
             if (msg.method === 'initialize') {
                 clientInitId = msg.id;
+                const initParams = (msg.params ?? {});
+                if (initParams.clientInfo) {
+                    telemetryClient = {
+                        name: typeof initParams.clientInfo.name === 'string' ? initParams.clientInfo.name : undefined,
+                        version: typeof initParams.clientInfo.version === 'string' ? initParams.clientInfo.version : undefined,
+                    };
+                }
                 writeClient({ jsonrpc: '2.0', id: msg.id, result: { protocolVersion: session_1.PROTOCOL_VERSION, capabilities: { tools: {} }, serverInfo: session_1.SERVER_INFO, instructions: server_instructions_1.SERVER_INSTRUCTIONS } });
                 routeToDaemon(line); // prime the daemon so it resolves the project (its reply is suppressed below)
             }
             else if (msg.method === 'tools/list') {
                 writeClient({ jsonrpc: '2.0', id: msg.id, result: { tools: (0, tools_1.getStaticTools)() } });
             }
+            else if (msg.method === 'resources/list') {
+                // No resources exposed — answer the probe locally so it never reaches
+                // the daemon as an unhandled method and logs `-32601`. (#621)
+                writeClient({ jsonrpc: '2.0', id: msg.id, result: { resources: [] } });
+            }
+            else if (msg.method === 'resources/templates/list') {
+                writeClient({ jsonrpc: '2.0', id: msg.id, result: { resourceTemplates: [] } });
+            }
+            else if (msg.method === 'prompts/list') {
+                writeClient({ jsonrpc: '2.0', id: msg.id, result: { prompts: [] } });
+            }
             else {
                 routeToDaemon(line);
             }
         }
     });
-    process.stdin.on('end', shutdown);
-    process.stdin.on('close', shutdown);
+    // Shut down when stdin ends/closes — and also on a stdin `'error'`, which a
+    // socket-backed stdin (the VS Code stdio shape) can emit on client death
+    // instead of a clean close; destroying the stream stops a hung fd from
+    // busy-spinning the event loop (#799).
+    (0, stdin_teardown_1.treatStdinFailureAsShutdown)(shutdown);
     startPpidWatchdogNoSocket(shutdown);
     // ---- daemon connection (background) ----
     let socket = null;
@@ -281,20 +370,45 @@ async function runLocalHandshakeProxy(deps) {
                 sockBuf = sockBuf.slice(idx + 1);
                 if (!line.trim())
                     continue;
-                if (clientInitId !== undefined) {
-                    try {
-                        const m = JSON.parse(line);
-                        if (m.id === clientInitId && ('result' in m || 'error' in m))
-                            continue;
-                    }
-                    catch { /* relay */ }
+                let resp = null;
+                try {
+                    resp = JSON.parse(line);
+                }
+                catch { /* not JSON — relay verbatim */ }
+                if (resp && resp.id !== undefined && ('result' in resp || 'error' in resp)) {
+                    inflight.delete(resp.id); // answered — no longer in flight
+                    // Suppress the daemon's reply to the initialize we forwarded to prime it
+                    // (the client already got the local handshake response).
+                    if (clientInitId !== undefined && resp.id === clientInitId)
+                        continue;
                 }
                 writeClient(line);
             }
         });
-        socket.on('close', shutdown);
-        socket.on('error', shutdown);
+        // The daemon going away does NOT end the session (#662). An MCP host can
+        // SIGTERM the shared daemon when another session starts; if we exited here,
+        // this host would silently lose CodeGraph and any in-flight request would
+        // hang. Instead, fall back to the in-process engine for the rest of the
+        // session and re-serve whatever the dead daemon never answered.
+        const onDaemonLost = () => {
+            if (shuttingDown || daemonStatus !== 'ready')
+                return; // host teardown, or already handled
+            daemonStatus = 'failed';
+            try {
+                daemonSocket?.destroy();
+            }
+            catch { /* ignore */ }
+            daemonSocket = null;
+            process.stderr.write(`[CodeGraph MCP] Shared daemon connection lost; serving this session in-process (degraded), re-serving ${inflight.size} in-flight request(s).\n`);
+            const orphaned = [...inflight.values()];
+            inflight.clear();
+            for (const line of orphaned)
+                void handleLocally(line);
+        };
+        socket.on('close', onDaemonLost);
+        socket.on('error', onDaemonLost);
         for (const line of pending) {
+            trackInflight(line);
             try {
                 socket.write(line + '\n');
             }
@@ -321,8 +435,14 @@ function startPpidWatchdogNoSocket(onDeath) {
     const originalPpid = process.ppid;
     const hostPpid = parseHostPpid(process.env[wasm_runtime_flags_1.HOST_PPID_ENV]);
     const timer = setInterval(() => {
-        if (process.ppid !== originalPpid || (hostPpid !== null && !isProcessAliveLocal(hostPpid))) {
-            process.stderr.write('[CodeGraph MCP] Parent process exited; shutting down.\n');
+        const reason = (0, ppid_watchdog_1.supervisionLostReason)({
+            originalPpid,
+            currentPpid: process.ppid,
+            hostPpid,
+            isAlive: isProcessAliveLocal,
+        });
+        if (reason) {
+            process.stderr.write(`[CodeGraph MCP] Parent process exited (${reason}); shutting down.\n`);
             onDeath();
         }
     }, pollMs);
@@ -412,13 +532,22 @@ function pipeUntilClose(socket) {
             catch { /* ignore */ }
             done();
         });
-        process.stdin.on('close', () => {
+        // 'close' and 'error' both tear down: a socket-backed stdin can fail with
+        // an 'error' (ECONNRESET/hangup) rather than a clean close; destroying it
+        // stops a hung fd from busy-spinning the event loop (#799).
+        const teardown = () => {
+            try {
+                process.stdin.destroy();
+            }
+            catch { /* ignore */ }
             try {
                 socket.destroy();
             }
             catch { /* ignore */ }
             done();
-        });
+        };
+        process.stdin.on('close', teardown);
+        process.stdin.on('error', teardown);
         socket.on('data', (chunk) => {
             try {
                 process.stdout.write(chunk);
@@ -449,13 +578,13 @@ function startPpidWatchdog(socket) {
     const originalPpid = process.ppid;
     const hostPpid = parseHostPpid(process.env[wasm_runtime_flags_1.HOST_PPID_ENV]);
     const timer = setInterval(() => {
-        const current = process.ppid;
-        const ppidChanged = current !== originalPpid;
-        const hostGone = hostPpid !== null && !isProcessAliveLocal(hostPpid);
-        if (ppidChanged || hostGone) {
-            const reason = ppidChanged
-                ? `ppid ${originalPpid} -> ${current}`
-                : `host pid ${hostPpid} exited`;
+        const reason = (0, ppid_watchdog_1.supervisionLostReason)({
+            originalPpid,
+            currentPpid: process.ppid,
+            hostPpid,
+            isAlive: isProcessAliveLocal,
+        });
+        if (reason) {
             process.stderr.write(`[CodeGraph MCP] Parent process exited (${reason}); shutting down.\n`);
             try {
                 socket.destroy();