@quolu/lattice 0.68.3 → 0.69.0

package/README.md

@@ -156,12 +156,23 @@ the operating AI.
 
 ```bash
 npm install -g @quolu/lattice
+lattice setup --json
 ```
 
 Requires **Node.js 22.13 or newer, except 25.x** (`engines: >=22.13 <25 || >=26`; Node 25's V8
 turboshaft WASM JIT breaks the bundled sensor, so it is blocked with a banner). The structure sensor ships inside the package — there is nothing
 else to install, and Lattice never falls back to a sensor on your `PATH`.
 
+`lattice setup`は既存のClaude・Codex・Grok・Cursor設定を検出し、LatticeのMCP登録、
+対応する製品hookの準備、設定読戻し、実MCPの初期化とtool一覧確認を一回で行う。
+AIの設定がまだ無い初回は`lattice setup --host claude --json`のように対象を指定する。
+全AIを明示する時は`--host all`を使う。再実行とnpm更新後も同じ入口である。
+
+結果はOS・AI・機能別に返す。Windows nativeの製品hookとGrokの製品hookは`unsupported`、
+利用者が無効化したMCPは`disabled`として保持する。対応MCPの登録・確認は続行し、
+全機能確認済みの`ready`だけexit 0、`partial`と`failed`はexit 1である。
+設定形式と機能表は[導入契約](https://github.com/kitepon/Lattice/blob/main/docs/01_integration-package.md#製品所有のai導入入口)を参照。
+
 ## Quick start
 
 Every project begins with typed discovery. Never guess from directory layout:
@@ -276,11 +287,15 @@ host where it is enabled; its supervised process replaces an older loaded versio
 
 ```bash
 npm install -g @quolu/lattice@latest
+lattice setup --json
 lattice --version
 lattice status --json
 lattice bridge status --json
 ```
 
+AI登録の診断は`lattice setup status --json`。`--host <AI>`で対象を限定でき、
+設定を変更せず現在の登録とMCP接続を確認する。既存の製品hook単独操作も維持する。
+
 ## Release
 
 Maintainers release Lattice from this repository. Update `package.json` and `CHANGELOG.md`, pass the
@@ -291,8 +306,9 @@ remote default branch.
 ```bash
 npm run ci
 npm run verify:release-commit
-npm publish --access public
+gh workflow run publish.yml --repo kitepon/Lattice --ref main
 npm install -g @quolu/lattice@<version>
+lattice setup --json
 lattice --version
 lattice status --json
 lattice bridge status --json

package/bin/lattice.mjs

@@ -123,6 +123,9 @@ if (help !== null) {
   process.exitCode = await runBridgeCli({
     argv: args.slice(1), stdout: process.stdout, stderr: process.stderr, env: process.env,
   });
+} else if (args[0] === 'setup') {
+  const { runSetupCli } = await import('../src/setup-cli.mjs');
+  process.exitCode = await runSetupCli({ argv: args.slice(1), stdout: process.stdout });
 } else if (args[0] === 'hooks') {
   const { runHooksCli } = await import('../src/hooks-cli.mjs');
   process.exitCode = await runHooksCli({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quolu/lattice",
-  "version": "0.68.3",
+  "version": "0.69.0",
   "description": "Schedulability compiler for multi-agent development: observe real code boundaries, refactor the conflicting seam, recompile the plan for parallel execution",
   "author": {
     "name": "Quo / クオ at kitepon.dev",
@@ -67,6 +67,7 @@
     "remark-gfm": "^4.0.1",
     "remark-parse": "^11.0.0",
     "sisteransi": "^1.0.5",
+    "toml-eslint-parser": "^1.0.3",
     "tree-sitter-wasms": "^0.1.11",
     "unified": "^11.0.5",
     "web-tree-sitter": "^0.25.3"

package/src/cli-help.mjs

@@ -14,6 +14,7 @@ Commands:
   runtime-errors <command>      Inspect the local runtime error store
   bridge <command>              Configure the optional network bridge
   hooks <command>               Install and run sensor-awareness hooks
+  setup [status]                AI別のMCP登録・製品hook準備・接続確認
 
 Options:
   -h, --help                    Show help
@@ -205,12 +206,21 @@ Commands:
 
 registerはLATTICE_BRIDGE_REGISTRAR_SSH_HOSTとLATTICE_BRIDGE_REGISTRAR_SCRIPTが
 両方設定されている時だけ動く。アドレスは送らず、remote側がssh送信元から決める。
+`,
+  setup: `Usage: lattice setup [status] [--host <claude|codex|grok|cursor|all>] [--json]
+
+host省略時は既存AI設定を検出する。明示hostは初回設定を作成する。
+setupは登録・hook準備・MCP接続確認まで実行する。更新後も同じコマンドを使う。
+statusは設定変更をせず登録とMCP接続を診断する。
+結果は機能別のverified／unsupported／disabled／failed。readyだけexit 0、partial／failedはexit 1。
+Windows製品hookとGrok製品hookは未対応として返し、MCPは独立して実行する。
 `,
   hooks: `Usage: lattice hooks <install|status|uninstall|emit> --host <claude|codex|cursor>
 `,
 });
 
 const SUBCOMMAND_USAGE = Object.freeze({
+  'setup status': 'setup status [--host <claude|codex|grok|cursor|all>] [--json]',
   status: 'status --json',
   'session-context': 'session-context --json',
   'plan create': 'plan create --input <file> [--serialization-reviewed] | --schema --json | --schema-version <1|2|3|4> --json',

package/src/hooks-cli.mjs

@@ -8,6 +8,7 @@ import {
 import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { hostPaths } from './setup-hosts.mjs';
 
 const INFO = 'INFO: このrepoにはLattice sensor index（.lattice/sensor/）があります。コード構造の調査はsensor入口（MCP: lattice_sensor_explore 等／CLI: lattice sensor）を優先できます。';
 const HOSTS = new Set(['claude', 'codex', 'cursor']);
@@ -32,10 +33,8 @@ function failure(stdout, code, message, exit = 1, detail) {
   return exit;
 }
 
-function configPath(home, host) {
-  if (host === 'claude') return path.join(home, '.claude/settings.json');
-  if (host === 'cursor') return path.join(home, '.cursor/hooks.json');
-  return path.join(home, '.codex/hooks.json');
+function configPath(env, host) {
+  return hostPaths(host, env).hooks;
 }
 
 function eventName(host) {
@@ -650,8 +649,8 @@ function exactHandler(item, expected) {
   return JSON.stringify(item) === JSON.stringify(expected);
 }
 
-async function hostDirectory(home, host) {
-  const directory = path.dirname(configPath(home, host));
+async function hostDirectory(env, host) {
+  const directory = path.dirname(configPath(env, host));
   try {
     const info = await lstat(directory);
     if (!info.isDirectory() || info.isSymbolicLink()) throw new Error('not a directory');
@@ -662,15 +661,14 @@ async function hostDirectory(home, host) {
 }
 
 async function mutate(host, env, stdout, uninstall, source, platform, testHooks) {
-  const home = env.HOME ?? os.homedir();
-  if (await hostDirectory(home, host) === null) {
+  if (await hostDirectory(env, host) === null) {
     return failure(stdout, 'HOST_NOT_PRESENT', 'host home directory is not present');
   }
   let current;
   try { current = await resolveCanonical(host, source, platform); } catch {
     return failure(stdout, 'INSTALL_SOURCE_UNRESOLVED', 'install source cannot be resolved');
   }
-  const target = configPath(home, host);
+  const target = configPath(env, host);
   for (let attempt = 0; attempt < 2; attempt += 1) {
     let prestate;
     try { prestate = await readConfig(target); } catch (error) {
@@ -759,14 +757,13 @@ function statusResult(host, target, canonicalCommand, state, matches, executable
 }
 
 async function status(host, env, stdout, source, platform, testHooks) {
-  const home = env.HOME ?? os.homedir();
-  const target = configPath(home, host);
+  const target = configPath(env, host);
   let argv;
   try { argv = await resolveCanonical(host, source, platform); } catch {
     writeJson(stdout, statusResult(host, target, null, 'unreadable', 0, false, 0));
     return 1;
   }
-  if (platform === 'win32' || await hostDirectory(home, host) === null) {
+  if (platform === 'win32' || await hostDirectory(env, host) === null) {
     writeJson(stdout, statusResult(host, target, shell(argv), 'unreadable', 0, false, 0));
     return 1;
   }

package/src/setup-cli.mjs

@@ -0,0 +1,120 @@
+import { access, lstat, mkdir, open, unlink } from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { runHooksCli, resolveStableNodePath } from './hooks-cli.mjs';
+import { SETUP_HOSTS, hostPaths } from './setup-hosts.mjs';
+import { mcpEntry, parseSetupConfig, readSetupFile, updateMcpConfig, writeSetupFile, setupError } from './setup-config.mjs';
+import { probeSetupMcp } from './setup-mcp-probe.mjs';
+
+const root = fileURLToPath(new URL('..', import.meta.url));
+const usage = 'lattice setup [status] [--host claude|codex|grok|cursor|all] [--json]';
+const typed = (error) => ({ state: 'failed', code: error.code ?? 'SETUP_FAILED', message: error.message });
+
+async function hookResult(host, options, statusOnly) {
+  if (host === 'grok') return { state: 'unsupported', code: 'HOST_FEATURE_UNSUPPORTED', message: 'Grokの製品hookは未対応です' };
+  if (options.platform === 'win32') return { state: 'unsupported', code: 'HOST_PLATFORM_UNSUPPORTED', message: 'Windows nativeの製品hookは未対応です' };
+  const invoke = async (command) => {
+    let output = '';
+    const exit = await runHooksCli({ argv: [command, '--host', host], env: options.env,
+      platform: options.platform, source: options.hookSource, stdout: { write: (text) => { output += text; } } });
+    return { exit, result: JSON.parse(output) };
+  };
+  if (!statusOnly) {
+    const installed = await invoke('install');
+    if (installed.exit !== 0) return { ...installed.result, state: 'failed' };
+  }
+  const status = await invoke('status');
+  return { ...status.result, state: status.exit === 0 && status.result.state === 'wired' ? 'verified' : 'failed' };
+}
+
+async function configureHost(host, options, statusOnly) {
+  const paths = hostPaths(host, options.env);
+  const result = { host, mcp: null, hooks: null };
+  try {
+    const before = await readSetupFile(paths.mcp);
+    const existing = mcpEntry(before.text, paths.format);
+    const previousArgs = existing?.args ?? [];
+    if (!Array.isArray(previousArgs) || previousArgs.some((arg) => typeof arg !== 'string')) {
+      throw setupError('CONFIG_INVALID', 'MCP引数は文字列配列である必要があります');
+    }
+    // 配布入口を交換し、利用者が指定した --path 等の引数は保持する。
+    const hasScript = /(?:^|[\\/])lattice-mcp\.mjs$/u.test(previousArgs[0] ?? '');
+    const preservedArgs = hasScript ? previousArgs.slice(1) : previousArgs;
+    const desired = { command: await resolveStableNodePath(options.execPath, { platform: options.platform }),
+      args: [options.mcpBin, ...preservedArgs] };
+    await access(options.mcpBin);
+    let action = 'unchanged';
+    if (!statusOnly) action = await writeSetupFile(paths.mcp, before, updateMcpConfig(before.text, paths.format, desired));
+    const saved = (await readSetupFile(paths.mcp)).text;
+    const entry = mcpEntry(saved, paths.format);
+    if (!entry || entry.command !== desired.command || JSON.stringify(entry.args) !== JSON.stringify(desired.args)) {
+      throw setupError('MCP_REGISTRATION_DRIFT', 'MCP登録が現在のLattice実行体と一致しません');
+    }
+    const disabledNames = host === 'grok' ? parseSetupConfig(saved, paths.format).value.disabled_mcp_servers : [];
+    if (entry.enabled === false || entry.disabled === true || (Array.isArray(disabledNames) && disabledNames.includes('lattice'))) {
+      result.mcp = { state: 'disabled', code: 'USER_DISABLED', config_path: paths.mcp, action };
+    } else {
+      result.mcp = { ...await options.probe(entry, { env: options.env }), config_path: paths.mcp, action };
+    }
+  } catch (error) { result.mcp = { ...typed(error), config_path: paths.mcp }; }
+  try {
+    if (!statusOnly && host !== 'grok' && options.platform !== 'win32') await mkdir(paths.directory, { recursive: true });
+    result.hooks = await hookResult(host, options, statusOnly);
+  } catch (error) { result.hooks = typed(error); }
+  return result;
+}
+
+export async function runSetupCli({ argv, stdout, env = process.env, platform = process.platform,
+  execPath = process.execPath, mcpBin = path.join(root, 'bin/lattice-mcp.mjs'),
+  hookSource = { execPath, binPath: path.join(root, 'bin/lattice.mjs') }, probe = probeSetupMcp }) {
+  let statusOnly = false;
+  let selection;
+  const args = [...argv];
+  if (args[0] === 'status') { statusOnly = true; args.shift(); }
+  if (args.at(-1) === '--json') args.pop();
+  if (args.length === 2 && args[0] === '--host' && [...SETUP_HOSTS, 'all'].includes(args[1])) selection = args[1];
+  else if (args.length !== 0) {
+    stdout.write(`${JSON.stringify({ schema: 'lattice.setup_error.v1', code: 'USAGE', message: usage })}\n`);
+    return 2;
+  }
+  let hosts = selection && selection !== 'all' ? [selection] : SETUP_HOSTS;
+  if (!selection) {
+    const detected = [];
+    for (const host of hosts) {
+      const paths = hostPaths(host, env);
+      try { await access(paths.directory); detected.push(host); } catch (error) {
+        if (error.code !== 'ENOENT') { detected.push(host); continue; }
+        if (host === 'claude') {
+          try { if ((await readSetupFile(paths.mcp)).exists) detected.push(host); }
+          catch { detected.push(host); }
+        }
+      }
+    }
+    hosts = detected;
+  }
+  const options = { env, platform, execPath, mcpBin, hookSource, probe };
+  const results = [];
+  for (const host of hosts) {
+    const paths = hostPaths(host, env);
+    let lock;
+    const lockPath = path.join(paths.directory, '.lattice-setup.lock');
+    try {
+      if (!statusOnly) {
+        await mkdir(paths.directory, { recursive: true });
+        if (!(await lstat(paths.directory)).isDirectory()) throw setupError('CONFIG_PATH_UNSUPPORTED', 'AI設定directoryが通常directoryではありません');
+        try { lock = await open(lockPath, 'wx', 0o600); } catch (error) {
+          if (error.code === 'EEXIST') throw setupError('SETUP_BUSY', '同じAI設定へのLattice setupが実行中です');
+          throw error;
+        }
+      }
+      results.push(await configureHost(host, options, statusOnly));
+    } catch (error) { results.push({ host, mcp: typed(error), hooks: typed(error) }); }
+    finally { if (lock) { await lock.close(); await unlink(lockPath); } }
+  }
+  const features = results.flatMap((host) => [host.mcp, host.hooks]);
+  const state = !hosts.length || features.some((feature) => feature.state === 'failed') ? 'failed'
+    : features.every((feature) => feature.state === 'verified') ? 'ready' : 'partial';
+  stdout.write(`${JSON.stringify({ schema: 'lattice.setup_result.v1', operation: statusOnly ? 'status' : 'setup',
+    platform, state, ...(hosts.length ? {} : { code: 'HOST_NOT_PRESENT' }), hosts: results })}\n`);
+  return state === 'ready' ? 0 : 1;
+}

package/src/setup-config.mjs

@@ -0,0 +1,124 @@
+import { parseForESLint, getStaticTOMLValue } from 'toml-eslint-parser';
+import { parseTree, getNodeValue, modify, applyEdits } from 'jsonc-parser';
+import { lstat, readFile, mkdir, open, rename, unlink, copyFile } from 'node:fs/promises';
+import { randomUUID } from 'node:crypto';
+import path from 'node:path';
+export const setupError = (code, message) => Object.assign(new Error(message), { code });
+const object = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
+
+export function parseSetupConfig(text, format) {
+  if (text.startsWith('\uFEFF')) text = text.slice(1);
+  try {
+    if (format === 'toml') {
+      const { ast } = parseForESLint(text, { tomlVersion: '1.0.0' });
+      return { ast, value: getStaticTOMLValue(ast) };
+    }
+    if (!text.trim()) return { value: {} };
+    const errors = [];
+    const ast = parseTree(text, errors, { allowTrailingComma: true });
+    if (errors.length || !ast || ast.type !== 'object') throw new Error('JSON構文が不正');
+    function uniqueKeys(node) {
+      if (node.type === 'object') {
+        const keys = node.children.map((property) => property.children[0].value);
+        if (new Set(keys).size !== keys.length) throw new Error('JSONキーが重複');
+      }
+      for (const child of node.children ?? []) uniqueKeys(child);
+    }
+    uniqueKeys(ast);
+    return { ast, value: getNodeValue(ast) };
+  } catch {
+    throw setupError('CONFIG_INVALID', 'AI設定の構文を解釈できないため変更しません');
+  }
+}
+
+const keyParts = (key) => key.keys.map((part) => part.name ?? part.value);
+const equalPath = (a, b) => a.length === b.length && a.every((part, i) => part === b[i]);
+const prefixPath = (a, b) => a.every((part, i) => part === b[i]);
+
+function setToml(text, keys, value) {
+  const { ast } = parseSetupConfig(text, 'toml');
+  let found;
+  let container = { prefix: [], node: ast.body[0] };
+  function visit(node, prefix) {
+    if (node.type === 'TOMLTable') prefix = node.resolvedKey;
+    if (['TOMLTable', 'TOMLInlineTable'].includes(node.type)
+      && prefixPath(prefix, keys) && prefix.length > container.prefix.length) container = { prefix, node };
+    if (node.type === 'TOMLKeyValue') {
+      const full = [...prefix, ...keyParts(node.key)];
+      if (equalPath(full, keys)) found = node.value;
+      if (node.value.type === 'TOMLInlineTable') visit(node.value, full);
+    } else for (const child of node.body ?? []) visit(child, prefix);
+  }
+  visit(ast.body[0], []);
+  const serialized = JSON.stringify(value);
+  if (found) return text.slice(0, found.range[0]) + serialized + text.slice(found.range[1]);
+  const assignment = `${keys.slice(container.prefix.length).map((part) => JSON.stringify(part)).join('.')} = ${serialized}`;
+  if (container.node.type === 'TOMLInlineTable') {
+    const at = container.node.range[1] - 1;
+    return text.slice(0, at) + (container.node.body.length ? ', ' : '') + assignment + text.slice(at);
+  }
+  if (container.node.type === 'TOMLTable') {
+    const newline = text.indexOf('\n', container.node.key.range[1]);
+    const at = newline < 0 ? text.length : newline + 1;
+    return text.slice(0, at) + (newline < 0 ? '\n' : '') + assignment + '\n' + text.slice(at);
+  }
+  return assignment + '\n' + text;
+}
+
+export function mcpEntry(text, format) {
+  const { value } = parseSetupConfig(text, format);
+  const servers = value[format === 'toml' ? 'mcp_servers' : 'mcpServers'];
+  if (servers !== undefined && !object(servers)) throw setupError('CONFIG_INVALID', 'MCP登録一覧がobjectではありません');
+  const entry = servers?.lattice;
+  if (entry !== undefined && !object(entry)) throw setupError('CONFIG_INVALID', 'Lattice登録がobjectではありません');
+  return entry;
+}
+
+export function updateMcpConfig(text, format, desired) {
+  if (text.startsWith('\uFEFF')) return '\uFEFF' + updateMcpConfig(text.slice(1), format, desired);
+  const current = mcpEntry(text, format);
+  if (current?.url || (current?.type && current.type !== 'stdio')) {
+    throw setupError('MCP_REGISTRATION_CONFLICT', 'lattice名の登録がstdioではないため保持しました');
+  }
+  let updated = text;
+  for (const [key, value] of Object.entries(desired)) {
+    if (JSON.stringify(current?.[key]) === JSON.stringify(value)) continue;
+    const keys = [format === 'toml' ? 'mcp_servers' : 'mcpServers', 'lattice', key];
+    updated = format === 'toml' ? setToml(updated, keys, value)
+      : applyEdits(updated, modify(updated, keys, value, {
+        formattingOptions: { insertSpaces: true, tabSize: 2, eol: text.includes('\r\n') ? '\r\n' : '\n' },
+      }));
+  }
+  mcpEntry(updated, format);
+  return updated;
+}
+
+export async function readSetupFile(target) {
+  let info;
+  try { info = await lstat(target); } catch (error) {
+    if (error.code === 'ENOENT') return { text: '', mode: 0o600, exists: false };
+    throw error;
+  }
+  if (!info.isFile() || info.isSymbolicLink()) throw setupError('CONFIG_PATH_UNSUPPORTED', '設定は通常fileだけを扱います');
+  return { text: await readFile(target, 'utf8'), mode: info.mode & 0o777, exists: true };
+}
+
+export async function writeSetupFile(target, before, text) {
+  if (text === before.text) return 'unchanged';
+  await mkdir(path.dirname(target), { recursive: true });
+  const current = await readSetupFile(target);
+  if (current.text !== before.text || current.exists !== before.exists) throw setupError('CONFIG_CHANGED', '設定が同時に変更されました');
+  const temporary = `${target}.lattice-${randomUUID()}`;
+  try {
+    const handle = await open(temporary, 'wx', before.mode);
+    try { await handle.writeFile(text); await handle.sync(); } finally { await handle.close(); }
+    const latest = await readSetupFile(target);
+    if (latest.text !== before.text || latest.exists !== before.exists) throw setupError('CONFIG_CHANGED', '設定が同時に変更されました');
+    if (before.exists) await copyFile(target, `${temporary}.backup`);
+    await rename(temporary, target);
+    if ((await readSetupFile(target)).text !== text) throw setupError('CONFIG_READBACK_FAILED', '設定の読戻しが一致しません');
+  } finally {
+    await unlink(temporary).catch((error) => { if (error.code !== 'ENOENT') throw error; });
+  }
+  return before.exists ? 'updated' : 'created';
+}

package/src/setup-hosts.mjs

@@ -0,0 +1,15 @@
+import path from 'node:path';
+import os from 'node:os';
+
+export const SETUP_HOSTS = ['claude', 'codex', 'grok', 'cursor'];
+
+export function hostPaths(host, env = process.env) {
+  const home = env.HOME || env.USERPROFILE || os.homedir();
+  const directory = path.resolve((host === 'claude' ? env.CLAUDE_CONFIG_DIR : null)
+    || (host === 'codex' ? env.CODEX_HOME : null)
+    || (host === 'grok' ? env.GROK_HOME : null) || path.join(home, `.${host}`));
+  return { directory, format: ['codex', 'grok'].includes(host) ? 'toml' : 'json',
+    mcp: host === 'claude' ? path.join(env.CLAUDE_CONFIG_DIR ? directory : home, '.claude.json')
+      : path.join(directory, ['codex', 'grok'].includes(host) ? 'config.toml' : 'mcp.json'),
+    hooks: path.join(directory, host === 'claude' ? 'settings.json' : 'hooks.json') };
+}

package/src/setup-mcp-probe.mjs

@@ -0,0 +1,71 @@
+import { spawn } from 'node:child_process';
+import { setupError } from './setup-config.mjs';
+
+/** 登録から起動したstdioの初期化とtool一覧を読戻す。AIへの推論依頼は行わない。 */
+export async function probeSetupMcp(entry, { env = process.env, timeoutMs = 15000 } = {}) {
+  const child = spawn(entry.command, entry.args ?? [], {
+    shell: false, stdio: ['pipe', 'pipe', 'pipe'], cwd: entry.cwd,
+    env: { ...env, ...entry.env }, windowsHide: true,
+  });
+  let buffer = '';
+  let initialized = false;
+  let result;
+  let failure;
+  const closed = new Promise((resolve) => child.once('close', resolve));
+  try {
+    result = await new Promise((resolve, reject) => {
+      const timer = setTimeout(() => reject(setupError('MCP_TIMEOUT', 'MCP接続確認が時間内に完了しません')), timeoutMs);
+      const finish = (error, value) => {
+        clearTimeout(timer);
+        if (error) reject(error); else resolve(value);
+      };
+      const send = (message) => child.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', ...message })}\n`);
+      child.once('error', () => finish(setupError('MCP_LAUNCH_FAILED', '登録されたMCP実行体を起動できません')));
+      child.stdin.on('error', () => finish(setupError('MCP_CONNECTION_CLOSED', 'MCP入力が閉じました')));
+      child.stderr.resume();
+      child.once('exit', () => finish(setupError('MCP_CONNECTION_CLOSED', '接続確認前にMCPが終了しました')));
+      child.stdout.setEncoding('utf8');
+      child.stdout.on('data', (chunk) => {
+        buffer += chunk;
+        if (buffer.length > 4 * 1024 * 1024) return finish(setupError('MCP_PROTOCOL_INVALID', 'MCP出力が上限を超えました'));
+        while (buffer.includes('\n')) {
+          const at = buffer.indexOf('\n');
+          const line = buffer.slice(0, at);
+          buffer = buffer.slice(at + 1);
+          if (!line.trim()) continue;
+          let response;
+          try { response = JSON.parse(line); } catch {
+            return finish(setupError('MCP_PROTOCOL_INVALID', 'MCP出力がJSON-RPCではありません'));
+          }
+          if (response.id === 1) {
+            if (response.error || response.result?.serverInfo?.name !== 'lattice-sensor') {
+              return finish(setupError('MCP_IDENTITY_MISMATCH', 'Lattice MCPの初期化結果を確認できません'));
+            }
+            initialized = true;
+            send({ method: 'notifications/initialized' });
+            send({ id: 2, method: 'tools/list', params: {} });
+          } else if (response.id === 2) {
+            const names = response.result?.tools?.map((tool) => tool.name);
+            if (!initialized || response.error || !names?.includes('lattice_sensor_explore')
+              || names.some((name) => !name.startsWith('lattice_sensor_'))) {
+              return finish(setupError('MCP_TOOLS_MISMATCH', 'Lattice sensorの公開toolを確認できません'));
+            }
+            finish(null, { state: 'verified', tool_count: names.length });
+          }
+        }
+      });
+      send({ id: 1, method: 'initialize', params: {
+        protocolVersion: '2024-11-05', capabilities: {},
+        clientInfo: { name: 'lattice-setup', version: '1' },
+      } });
+    });
+  } catch (error) { failure = error; }
+  finally {
+    child.stdin.end();
+    const timer = setTimeout(() => child.kill('SIGKILL'), 2000);
+    await closed;
+    clearTimeout(timer);
+  }
+  if (failure) throw failure;
+  return result;
+}