@akiojin/unity-mcp-server 5.2.1 → 5.3.2

package/src/handlers/addressables/AddressablesAnalyzeToolHandler.js

@@ -7,7 +7,7 @@ import { BaseToolHandler } from '../base/BaseToolHandler.js';
 export default class AddressablesAnalyzeToolHandler extends BaseToolHandler {
   constructor(unityConnection) {
     super(
-      'analyze_addressables',
+      'addressables_analyze',
       'Analyze Unity Addressables for duplicates, dependencies, and unused assets',
       {
         type: 'object',
@@ -61,17 +61,25 @@ export default class AddressablesAnalyzeToolHandler extends BaseToolHandler {
   }
 
   async execute(params) {
-    const { action, ...parameters } = params;
+    const { action, workspaceRoot, ...parameters } = params;
 
     // Ensure connected
     if (!this.unityConnection.isConnected()) {
       await this.unityConnection.connect();
     }
 
-    const result = await this.unityConnection.sendCommand('analyze_addressables', {
-      action,
-      ...parameters
-    });
+    const { WORKSPACE_ROOT } = await import('../../core/config.js');
+    const resolvedWorkspaceRoot = workspaceRoot ?? WORKSPACE_ROOT;
+    const timeout = 300000; // 5 minutes
+    const result = await this.unityConnection.sendCommand(
+      'addressables_analyze',
+      {
+        action,
+        workspaceRoot: resolvedWorkspaceRoot,
+        ...parameters
+      },
+      timeout
+    );
 
     return this.formatResponse(action, result);
   }

package/src/handlers/addressables/AddressablesBuildToolHandler.js

@@ -6,7 +6,7 @@ import { BaseToolHandler } from '../base/BaseToolHandler.js';
  */
 export default class AddressablesBuildToolHandler extends BaseToolHandler {
   constructor(unityConnection) {
-    super('build_addressables', 'Build Unity Addressables content or clean build cache', {
+    super('addressables_build', 'Build Unity Addressables content or clean build cache', {
       type: 'object',
       properties: {
         action: {
@@ -64,7 +64,7 @@ export default class AddressablesBuildToolHandler extends BaseToolHandler {
   }
 
   async execute(params) {
-    const { action, ...parameters } = params;
+    const { action, workspaceRoot, ...parameters } = params;
 
     // Ensure connected
     if (!this.unityConnection.isConnected()) {
@@ -74,10 +74,13 @@ export default class AddressablesBuildToolHandler extends BaseToolHandler {
     // Build operations can take several minutes
     const timeout = 300000; // 5 minutes
 
+    const { WORKSPACE_ROOT } = await import('../../core/config.js');
+    const resolvedWorkspaceRoot = workspaceRoot ?? WORKSPACE_ROOT;
     const result = await this.unityConnection.sendCommand(
-      'build_addressables',
+      'addressables_build',
       {
         action,
+        workspaceRoot: resolvedWorkspaceRoot,
         ...parameters
       },
       timeout

package/src/handlers/addressables/AddressablesManageToolHandler.js

@@ -7,7 +7,7 @@ import { BaseToolHandler } from '../base/BaseToolHandler.js';
 export default class AddressablesManageToolHandler extends BaseToolHandler {
   constructor(unityConnection) {
     super(
-      'manage_addressables',
+      'addressables_manage',
       'Manage Unity Addressables assets and groups - add, remove, organize entries and groups',
       {
         type: 'object',
@@ -134,15 +134,18 @@ export default class AddressablesManageToolHandler extends BaseToolHandler {
   }
 
   async execute(params) {
-    const { action, ...parameters } = params;
+    const { action, workspaceRoot, ...parameters } = params;
 
     // Ensure connected
     if (!this.unityConnection.isConnected()) {
       await this.unityConnection.connect();
     }
 
-    const result = await this.unityConnection.sendCommand('manage_addressables', {
+    const { WORKSPACE_ROOT } = await import('../../core/config.js');
+    const resolvedWorkspaceRoot = workspaceRoot ?? WORKSPACE_ROOT;
+    const result = await this.unityConnection.sendCommand('addressables_manage', {
       action,
+      workspaceRoot: resolvedWorkspaceRoot,
       ...parameters
     });
 

package/src/handlers/input/InputSystemControlToolHandler.js

@@ -5,7 +5,7 @@ import { BaseToolHandler } from '../base/BaseToolHandler.js';
  */
 export class InputSystemControlToolHandler extends BaseToolHandler {
   constructor(unityConnection) {
-    super('control_input_system', 'Main handler for Input System operations', {
+    super('input_system_control', 'Main handler for Input System operations', {
       type: 'object',
       properties: {
         operation: {

package/src/handlers/input/InputTouchToolHandler.js

@@ -127,7 +127,7 @@ function validateTouchAction(params, context = 'action') {
  */
 export class InputTouchToolHandler extends BaseToolHandler {
   constructor(unityConnection) {
-    super('simulate_touch', 'Touch input (tap/swipe/pinch/multi) with batching.', {
+    super('input_touch', 'Touch input (tap/swipe/pinch/multi) with batching.', {
       type: 'object',
       properties: {
         ...actionProperties,
@@ -178,10 +178,14 @@ export class InputTouchToolHandler extends BaseToolHandler {
       await this.unityConnection.connect();
     }
 
+    const { WORKSPACE_ROOT } = await import('../../core/config.js');
+    const resolvedWorkspaceRoot = params.workspaceRoot ?? WORKSPACE_ROOT;
     const hasBatch = Array.isArray(params.actions) && params.actions.length > 0;
-    const payload = hasBatch ? { actions: params.actions } : params;
+    const payload = hasBatch
+      ? { actions: params.actions, workspaceRoot: resolvedWorkspaceRoot }
+      : { ...params, workspaceRoot: resolvedWorkspaceRoot };
 
-    const result = await this.unityConnection.sendCommand('simulate_touch', payload);
+    const result = await this.unityConnection.sendCommand('input_touch', payload);
     return result;
   }
 }

package/src/handlers/package/PackageManagerToolHandler.js

@@ -7,7 +7,7 @@ import { BaseToolHandler } from '../base/BaseToolHandler.js';
 
 export default class PackageManagerToolHandler extends BaseToolHandler {
   constructor(unityConnection) {
-    super('manage_packages', 'Manage Unity packages - search, install, remove, and list packages', {
+    super('package_manager', 'Manage Unity packages - search, install, remove, and list packages', {
       type: 'object',
       properties: {
         action: {
@@ -77,15 +77,18 @@ export default class PackageManagerToolHandler extends BaseToolHandler {
   }
 
   async execute(params) {
-    const { action, ...parameters } = params;
+    const { action, workspaceRoot, ...parameters } = params;
 
     // Ensure connected
     if (!this.unityConnection.isConnected()) {
       await this.unityConnection.connect();
     }
 
-    const result = await this.unityConnection.sendCommand('manage_packages', {
+    const { WORKSPACE_ROOT } = await import('../../core/config.js');
+    const resolvedWorkspaceRoot = workspaceRoot ?? WORKSPACE_ROOT;
+    const result = await this.unityConnection.sendCommand('package_manager', {
       action,
+      workspaceRoot: resolvedWorkspaceRoot,
       ...parameters
     });
 

package/src/handlers/script/CodeIndexStatusToolHandler.js

@@ -22,7 +22,11 @@ export class CodeIndexStatusToolHandler extends BaseToolHandler {
     const jobManager = this.jobManager;
     const buildJobs = jobManager
       .getAllJobs()
-      .filter(job => typeof job?.id === 'string' && job.id.startsWith('build-'))
+      .filter(
+        job =>
+          typeof job?.id === 'string' &&
+          (job.id.startsWith('build-') || job.id.startsWith('watcher-'))
+      )
       .sort((a, b) => new Date(b.startedAt || 0).getTime() - new Date(a.startedAt || 0).getTime());
     const latestBuildJob = buildJobs.length > 0 ? buildJobs[0] : null;
 
@@ -51,6 +55,38 @@ export class CodeIndexStatusToolHandler extends BaseToolHandler {
     }
     const buildInProgress = latestBuildJob?.status === 'running';
     if (!ready && !buildInProgress) {
+      if (latestBuildJob) {
+        const indexInfo = {
+          ready: false,
+          rows: 0,
+          lastIndexedAt: null,
+          buildJob: {
+            id: latestBuildJob.id,
+            status: latestBuildJob.status,
+            startedAt: latestBuildJob.startedAt ?? null
+          }
+        };
+        if (latestBuildJob.status === 'completed') {
+          indexInfo.buildJob.completedAt = latestBuildJob.completedAt ?? null;
+          indexInfo.buildJob.result = latestBuildJob.result ?? null;
+        } else if (latestBuildJob.status === 'failed') {
+          indexInfo.buildJob.failedAt = latestBuildJob.failedAt ?? null;
+          indexInfo.buildJob.error = latestBuildJob.error ?? 'Unknown error';
+        }
+        return {
+          success: true,
+          status: latestBuildJob.status === 'failed' ? 'failed' : 'pending',
+          ready: false,
+          totalFiles: 0,
+          indexedFiles: 0,
+          coverage: 0,
+          message:
+            latestBuildJob.status === 'failed'
+              ? 'Code index build failed. Check buildJob error or rerun build_index.'
+              : 'Code index is not ready yet. A build job exists but has not produced a usable index.',
+          index: indexInfo
+        };
+      }
       return {
         success: false,
         error: 'index_not_built',

package/src/handlers/script/CodeIndexUpdateToolHandler.js

@@ -60,7 +60,7 @@ export class CodeIndexUpdateToolHandler extends BaseToolHandler {
     const projectRoot = info.projectRoot;
 
     if (!this.lsp) {
-      this.lsp = await LspRpcClientSingleton.getInstance(projectRoot);
+      this.lsp = await LspRpcClientSingleton.getIsolatedInstance(projectRoot, 'update_index');
     }
 
     const normalized = requested.map(p => this._normalizePath(p, projectRoot));

package/src/handlers/script/ScriptEditSnippetToolHandler.js

@@ -9,7 +9,6 @@ import { preSyntaxCheck } from './csharpSyntaxCheck.js';
 const MAX_INSTRUCTIONS = 10;
 const MAX_DIFF_CHARS = 80;
 const PREVIEW_MAX = 1000;
-
 const normalizeSlashes = p => p.replace(/\\/g, '/');
 
 export class ScriptEditSnippetToolHandler extends BaseToolHandler {
@@ -297,7 +296,7 @@ export class ScriptEditSnippetToolHandler extends BaseToolHandler {
 
   async #validateWithLsp(info, relative, updatedText) {
     if (!this.lsp) {
-      this.lsp = await LspRpcClientSingleton.getInstance(info.projectRoot);
+      this.lsp = await LspRpcClientSingleton.getValidationInstance(info.projectRoot);
     }
     return await this.lsp.validateText(relative, updatedText);
   }

package/src/handlers/script/ScriptEditStructuredToolHandler.js

@@ -110,7 +110,12 @@ export class ScriptEditStructuredToolHandler extends BaseToolHandler {
       }
     }
 
-    if (!this.lsp) this.lsp = await LspRpcClientSingleton.getInstance(info.projectRoot);
+    if (!this.lsp) {
+      this.lsp = await LspRpcClientSingleton.getIsolatedInstance(
+        info.projectRoot,
+        'edit_structured'
+      );
+    }
 
     if (operation === 'replace_body') {
       const resp = await this.lsp.request('mcp/replaceSymbolBody', {

package/src/handlers/script/ScriptRefactorRenameToolHandler.js

@@ -38,7 +38,9 @@ export class ScriptRefactorRenameToolHandler extends BaseToolHandler {
   async execute(params) {
     const { relative, namePath, newName, preview = true } = params;
     const info = await this.projectInfo.get();
-    if (!this.lsp) this.lsp = await LspRpcClientSingleton.getInstance(info.projectRoot);
+    if (!this.lsp) {
+      this.lsp = await LspRpcClientSingleton.getIsolatedInstance(info.projectRoot, 'rename');
+    }
     const resp = await this.lsp.request('mcp/renameByNamePath', {
       relative: String(relative).replace(/\\\\/g, '/'),
       namePath: String(namePath),

package/src/handlers/script/ScriptRefsFindToolHandler.js

@@ -9,7 +9,7 @@ export class ScriptRefsFindToolHandler extends BaseToolHandler {
   constructor(unityConnection) {
     super(
       'find_refs',
-      '[OFFLINE] No Unity connection required. Find code references/usages using fast file-based search. LLM-friendly paging/summary: respects pageSize and maxBytes, caps matches per file (maxMatchesPerFile), and trims snippet text to ~400 chars. Use scope/name/kind/path to narrow results.',
+      '[OFFLINE] No Unity connection required. Find code references/usages using fast file-based search. LLM-friendly paging/summary: respects pageSize and maxBytes, caps matches per file (maxMatchesPerFile), and trims snippet text to ~400 chars. Use scope/name/kind/path to narrow results. Use startAfter to continue from a cursor (file path).',
       {
         type: 'object',
         properties: {
@@ -17,6 +17,10 @@ export class ScriptRefsFindToolHandler extends BaseToolHandler {
             type: 'string',
             description: 'Symbol name to search usages for.'
           },
+          startAfter: {
+            type: 'string',
+            description: 'Pagination cursor (file path). Return only results after this path.'
+          },
           scope: {
             type: 'string',
             enum: ['assets', 'packages', 'embedded', 'all'],
@@ -78,6 +82,7 @@ export class ScriptRefsFindToolHandler extends BaseToolHandler {
   async execute(params) {
     const {
       name,
+      startAfter,
       scope = 'all',
       pageSize = 50,
       maxBytes = 1024 * 64,
@@ -219,8 +224,16 @@ export class ScriptRefsFindToolHandler extends BaseToolHandler {
     let bytes = 0;
     let total = 0;
     let truncated = false;
-
-    for (const [filePath, arr] of perFile) {
+    let lastPath = null;
+    let started = !startAfter;
+    const sortedPaths = Array.from(perFile.keys()).sort();
+
+    for (const filePath of sortedPaths) {
+      if (!started) {
+        if (filePath <= startAfter) continue;
+        started = true;
+      }
+      const arr = perFile.get(filePath) || [];
       const references = [];
       for (const it of arr) {
         const ref = {
@@ -243,6 +256,7 @@ export class ScriptRefsFindToolHandler extends BaseToolHandler {
 
       if (references.length > 0) {
         results.push({ path: filePath, references });
+        lastPath = filePath;
       }
 
       if (truncated) break;
@@ -254,7 +268,11 @@ export class ScriptRefsFindToolHandler extends BaseToolHandler {
       truncated = true;
     }
 
-    return { success: true, results, total, truncated };
+    const response = { success: true, results, total, truncated };
+    if (truncated && lastPath) {
+      response.cursor = lastPath;
+    }
+    return response;
   }
 }
 

package/src/handlers/script/ScriptRemoveSymbolToolHandler.js

@@ -39,7 +39,12 @@ export class ScriptRemoveSymbolToolHandler extends BaseToolHandler {
       removeEmptyFile = false
     } = params;
     const info = await this.projectInfo.get();
-    if (!this.lsp) this.lsp = await LspRpcClientSingleton.getInstance(info.projectRoot);
+    if (!this.lsp) {
+      this.lsp = await LspRpcClientSingleton.getIsolatedInstance(
+        info.projectRoot,
+        'remove_symbol'
+      );
+    }
     const resp = await this.lsp.request('mcp/removeSymbol', {
       relative: String(path).replace(/\\\\/g, '/'),
       namePath: String(namePath),

package/src/handlers/script/ScriptSymbolsGetToolHandler.js

@@ -65,7 +65,7 @@ export class ScriptSymbolsGetToolHandler extends BaseToolHandler {
         };
       }
       try {
-        const lsp = await LspRpcClientSingleton.getInstance(info.projectRoot);
+        const lsp = await LspRpcClientSingleton.getIsolatedInstance(info.projectRoot, 'symbols');
         const uri = 'file://' + abs.replace(/\\\\/g, '/');
         const res = await lsp.request('textDocument/documentSymbol', { textDocument: { uri } });
         const docSymbols = res?.result ?? res ?? [];

package/src/lsp/CSharpLspUtils.js

@@ -92,18 +92,26 @@ export class CSharpLspUtils {
   async ensureLocal(rid) {
     const p = this.getLocalPath(rid);
     const desired = this.getDesiredVersion();
+    const binaryExists = fs.existsSync(p);
+    const current = this.readLocalVersion(rid);
+    const isTestMode = process.env.NODE_ENV === 'test';
 
     // バージョン取得失敗時もバイナリが存在すれば使用
     if (!desired) {
-      if (fs.existsSync(p)) {
+      if (binaryExists) {
         logger.warning('[unity-mcp-server:lsp] version not found, using existing binary');
         return p;
       }
       throw new Error('mcp-server version not found; cannot resolve LSP tag');
     }
 
-    const current = this.readLocalVersion(rid);
-    if (fs.existsSync(p) && current === desired) return p;
+    if (binaryExists && current === desired) return p;
+
+    // テスト環境では既存バイナリを優先し、並列ダウンロードによる不安定化を防ぐ
+    if (binaryExists && isTestMode) {
+      this.writeLocalVersion(rid, desired);
+      return p;
+    }
 
     // ダウンロード失敗時のフォールバック
     try {

package/src/lsp/LspProcessManager.js

@@ -4,28 +4,45 @@ import { CSharpLspUtils } from './CSharpLspUtils.js';
 
 const sharedState = {
   proc: null,
-  starting: null
+  starting: null,
+  version: null
 };
 
 export class LspProcessManager {
-  constructor() {
-    this.state = sharedState;
+  constructor(options = {}) {
+    const useShared = options.shared !== false;
+    this.state = useShared ? sharedState : { proc: null, starting: null, version: null };
     this.utils = new CSharpLspUtils();
   }
 
   async ensureStarted() {
-    if (this.state.proc && !this.state.proc.killed) return this.state.proc;
+    const rid = this.utils.detectRid();
+    const desired = this.utils.getDesiredVersion();
+    if (this.state.proc && !this.state.proc.killed) {
+      const local = this.utils.readLocalVersion(rid);
+      const procVersion = this.state.version;
+      const desiredVersion = desired || local || null;
+      if (procVersion && desiredVersion && procVersion !== desiredVersion) {
+        logger.warning(
+          `[unity-mcp-server:lsp] version changed (proc=${procVersion}, desired=${desiredVersion}), restarting`
+        );
+        await this.stop();
+      } else {
+        return this.state.proc;
+      }
+    }
     if (this.state.starting) return this.state.starting;
     this.state.starting = (async () => {
       try {
-        const rid = this.utils.detectRid();
         const bin = await this.utils.ensureLocal(rid);
+        const resolvedVersion = this.utils.readLocalVersion(rid) || desired || null;
         const proc = spawn(bin, { stdio: ['pipe', 'pipe', 'pipe'] });
         proc.on('error', e => logger.error(`[unity-mcp-server:lsp] process error: ${e.message}`));
         proc.on('close', (code, sig) => {
           logger.warning(`[unity-mcp-server:lsp] exited code=${code} signal=${sig || ''}`);
           if (this.state.proc === proc) {
             this.state.proc = null;
+            this.state.version = null;
           }
         });
         proc.stderr.on('data', d => {
@@ -33,6 +50,7 @@ export class LspProcessManager {
           if (s) logger.debug(`[unity-mcp-server:lsp] ${s}`);
         });
         this.state.proc = proc;
+        this.state.version = resolvedVersion;
         logger.info(`[unity-mcp-server:lsp] started (pid=${proc.pid})`);
         return proc;
       } catch (e) {
@@ -51,6 +69,7 @@ export class LspProcessManager {
     if (!this.state.proc || this.state.proc.killed) return;
     const p = this.state.proc;
     this.state.proc = null;
+    this.state.version = null;
 
     // Remove all listeners to prevent memory leaks
     try {

package/src/lsp/LspRpcClient.js

@@ -2,8 +2,8 @@ import { LspProcessManager } from './LspProcessManager.js';
 import { config, logger } from '../core/config.js';
 
 export class LspRpcClient {
-  constructor(projectRoot = null) {
-    this.mgr = new LspProcessManager();
+  constructor(projectRoot = null, manager = null) {
+    this.mgr = manager || new LspProcessManager();
     this.proc = null;
     this.seq = 1;
     this.pending = new Map();
@@ -13,19 +13,39 @@ export class LspRpcClient {
     this.boundOnData = null;
   }
 
-  async ensure() {
-    if (this.proc && !this.proc.killed) return this.proc;
-    this.proc = await this.mgr.ensureStarted();
+  async ensure(attempt = 1) {
+    if (this.#isProcessUsable(this.proc)) {
+      return this.proc;
+    }
+
+    if (this.proc && !this.#isProcessUsable(this.proc)) {
+      logger.warning('[unity-mcp-server:lsp] cached process stdin not writable, restarting');
+      await this.#restartProcess(this.proc);
+    }
+
+    const proc = await this.mgr.ensureStarted();
+    this.proc = proc;
+
+    if (!this.#isProcessUsable(proc)) {
+      if (attempt === 1) {
+        logger.warning('[unity-mcp-server:lsp] started process has non-writable stdin, retrying');
+        await this.#restartProcess(proc);
+        return await this.ensure(attempt + 1);
+      }
+      throw new Error('LSP stdin not writable');
+    }
+
     // Attach data handler once per process
     if (this.boundOnData) {
       try {
-        this.proc.stdout.off('data', this.boundOnData);
+        proc.stdout.off('data', this.boundOnData);
       } catch {}
     }
     this.boundOnData = chunk => this.onData(chunk);
-    this.proc.stdout.on('data', this.boundOnData);
+    proc.stdout.on('data', this.boundOnData);
+
     // On process close: reject all pending and reset state
-    this.proc.on('close', () => {
+    proc.on('close', () => {
       for (const [id, p] of Array.from(this.pending.entries())) {
         try {
           p.reject(new Error('LSP process exited'));
@@ -35,8 +55,24 @@ export class LspRpcClient {
       this.initialized = false;
       this.proc = null;
     });
-    if (!this.initialized) await this.initialize();
-    return this.proc;
+
+    if (!this.initialized) {
+      try {
+        await this.initialize();
+      } catch (e) {
+        const msg = String((e && e.message) || e);
+        if (attempt === 1 && this.#isRecoverableMessage(msg)) {
+          logger.warning(
+            `[unity-mcp-server:lsp] initialize recoverable error: ${msg}. Restarting once...`
+          );
+          await this.#restartProcess(proc);
+          return await this.ensure(attempt + 1);
+        }
+        throw e;
+      }
+    }
+
+    return proc;
   }
 
   onData(chunk) {
@@ -135,24 +171,51 @@ export class LspRpcClient {
   }
 
   async #requestWithRetry(method, params, attempt) {
-    await this.ensure();
-    const id = this.seq++;
+    let id = null;
+    let timeoutHandle = null;
     const timeoutMs = Math.max(1000, Math.min(300000, config.lsp?.requestTimeoutMs || 60000));
-    const p = new Promise((resolve, reject) => {
-      this.pending.set(id, { resolve, reject });
-      setTimeout(() => {
-        if (this.pending.has(id)) {
-          this.pending.delete(id);
-          reject(new Error(`${method} timed out after ${timeoutMs} ms`));
-        }
-      }, timeoutMs);
-    });
+    const startedAt = Date.now();
     try {
+      await this.ensure();
+      id = this.seq++;
+      const p = new Promise((resolve, reject) => {
+        this.pending.set(id, { resolve, reject });
+        timeoutHandle = setTimeout(() => {
+          if (this.pending.has(id)) {
+            this.pending.delete(id);
+            reject(new Error(`${method} timed out after ${timeoutMs} ms`));
+          }
+        }, timeoutMs);
+      });
       this.writeMessage({ jsonrpc: '2.0', id, method, params });
-      return await p;
+      const response = await p;
+      if (timeoutHandle) clearTimeout(timeoutHandle);
+      const elapsedMs = Date.now() - startedAt;
+      const warnMs = Number.isFinite(config.lsp?.slowRequestWarnMs)
+        ? config.lsp.slowRequestWarnMs
+        : 2000;
+      if (elapsedMs >= warnMs) {
+        logger.warning(
+          `[unity-mcp-server:lsp] slow request: ${method} ${elapsedMs}ms (attempt ${attempt})`
+        );
+      }
+      return response;
     } catch (e) {
+      if (timeoutHandle) clearTimeout(timeoutHandle);
+      if (id !== null && this.pending.has(id)) {
+        this.pending.delete(id);
+      }
+      const elapsedMs = Date.now() - startedAt;
+      const warnMs = Number.isFinite(config.lsp?.slowRequestWarnMs)
+        ? config.lsp.slowRequestWarnMs
+        : 2000;
+      if (elapsedMs >= warnMs) {
+        logger.warning(
+          `[unity-mcp-server:lsp] slow request (error): ${method} ${elapsedMs}ms (attempt ${attempt})`
+        );
+      }
       const msg = String((e && e.message) || e);
-      const recoverable = /timed out|LSP process exited/i.test(msg);
+      const recoverable = this.#isRecoverableMessage(msg);
       if (recoverable && attempt === 1) {
         // Auto-reinit and retry once with grace period for proper LSP shutdown
         try {
@@ -180,4 +243,33 @@ export class LspRpcClient {
       throw new Error(`[${method}] failed: ${msg}. ${hint}`);
     }
   }
+
+  #isProcessUsable(proc) {
+    return Boolean(
+      proc &&
+        !proc.killed &&
+        proc.stdin &&
+        !proc.stdin.destroyed &&
+        !proc.stdin.writableEnded &&
+        typeof proc.stdin.write === 'function'
+    );
+  }
+
+  #isRecoverableMessage(message) {
+    return /timed out|LSP process exited|stdin not writable|process not available/i.test(message);
+  }
+
+  async #restartProcess(proc) {
+    if (proc && this.boundOnData) {
+      try {
+        proc.stdout.off('data', this.boundOnData);
+      } catch {}
+    }
+    try {
+      await this.mgr.stop(0);
+    } catch {}
+    this.proc = null;
+    this.initialized = false;
+    this.buf = Buffer.alloc(0);
+  }
 }