threadroot 0.1.2 → 0.1.4

package/dist/index.js

@@ -5,11 +5,11 @@ import { Command } from "commander";
 
 // src/core/bootstrap.ts
 import { stat as stat9 } from "fs/promises";
-import path22 from "path";
+import path23 from "path";
 
 // src/core/doctor.ts
 import { stat as stat5 } from "fs/promises";
-import path14 from "path";
+import path15 from "path";
 
 // src/core/compile/index.ts
 import { readFile, stat } from "fs/promises";
@@ -1799,12 +1799,15 @@ function codexAgentsBlock() {
     ""
   ].join("\n");
 }
-function codexMcpBlock() {
+function tomlString(value) {
+  return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+function codexMcpBlock(entry) {
   return [
     CODEX_MCP_BEGIN,
     "[mcp_servers.threadroot]",
-    'command = "threadroot"',
-    'args = ["mcp"]',
+    `command = ${tomlString(entry.command)}`,
+    `args = [${entry.args.map(tomlString).join(", ")}]`,
     CODEX_MCP_END,
     ""
   ].join("\n");
@@ -1897,7 +1900,7 @@ async function setupCodexAgents(home, mode) {
   await writeFile4(filePath, desired, "utf8");
   return { kind: "codex-agents", agent: "codex", label: "Codex global AGENTS.md", path: shown, status };
 }
-async function setupCodexMcp(home, mode) {
+async function setupCodexMcp(home, mode, entry) {
   const filePath = codexConfigPath(home);
   const shown = displayPath(home, filePath);
   const existing = await readMaybe(filePath) ?? "";
@@ -1911,7 +1914,7 @@ async function setupCodexMcp(home, mode) {
       message: "Existing unmanaged [mcp_servers.threadroot] table found. Leaving it untouched."
     };
   }
-  const desired = upsertManagedBlock(existing, codexMcpBlock(), CODEX_MCP_BEGIN, CODEX_MCP_END);
+  const desired = upsertManagedBlock(existing, codexMcpBlock(entry), CODEX_MCP_BEGIN, CODEX_MCP_END);
   if (mode === "check") {
     return {
       kind: "codex-mcp",
@@ -1950,7 +1953,7 @@ async function setupGlobal(options = {}) {
   if (providerIds.includes("codex")) {
     entries.push(await setupCodexAgents(home, mode));
     if (options.mcp) {
-      entries.push(await setupCodexMcp(home, mode));
+      entries.push(await setupCodexMcp(home, mode, options.mcpEntry ?? { command: "threadroot", args: ["mcp"] }));
     }
   }
   return { entries };
@@ -2390,6 +2393,390 @@ async function checkToolHealth(repoRoot, tool) {
   return { status: "ok", tool: tool.name, result };
 }
 
+// src/core/mcp-check.ts
+import { spawn as spawn2 } from "child_process";
+import { access, mkdtemp, readFile as readFile8, rm as rm2, writeFile as writeFile6 } from "fs/promises";
+import { constants, realpathSync } from "fs";
+import { homedir as homedir2, tmpdir } from "os";
+import path14 from "path";
+
+// src/core/version.ts
+var THREADROOT_VERSION = "0.1.4";
+
+// src/core/mcp-check.ts
+var REQUIRED_MCP_TOOLS = [
+  "context",
+  "skills_list",
+  "skills_get",
+  "tools_list",
+  "tools_check",
+  "tools_run",
+  "tools_create",
+  "tools_detect",
+  "connections_list",
+  "connections_check",
+  "memory_read",
+  "memory_append",
+  "status",
+  "doctor"
+];
+function codexConfigPath2(home = homedir2()) {
+  return path14.join(home, ".codex", "config.toml");
+}
+function mcpEntryForCurrentProcess() {
+  return mcpEntryForScriptPath(process.argv[1]);
+}
+function mcpEntryForScriptPath(rawScriptPath) {
+  const scriptPath = currentScriptPath(rawScriptPath);
+  if (scriptPath && isNpxPackagePath(scriptPath)) {
+    return { command: "npx", args: ["--yes", `threadroot@${THREADROOT_VERSION}`, "mcp"] };
+  }
+  if (scriptPath && path14.basename(scriptPath) === "index.js" && scriptPath.includes(`${path14.sep}dist${path14.sep}`)) {
+    return { command: process.execPath, args: [scriptPath, "mcp"] };
+  }
+  return { command: "threadroot", args: ["mcp"] };
+}
+function currentScriptPath(scriptPath) {
+  if (!scriptPath) {
+    return void 0;
+  }
+  try {
+    return realpathSync(scriptPath);
+  } catch {
+    return scriptPath;
+  }
+}
+function isNpxPackagePath(scriptPath) {
+  const normalized = scriptPath.split(path14.sep).join("/");
+  return normalized.includes("/.npm/_npx/") && normalized.includes("/node_modules/threadroot/");
+}
+async function readCodexThreadrootMcpEntry(home = homedir2()) {
+  let raw;
+  try {
+    raw = await readFile8(codexConfigPath2(home), "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return void 0;
+    }
+    throw error;
+  }
+  const table = raw.match(/(?:^|\n)\[mcp_servers\.threadroot\]\s*\n(?<body>[\s\S]*?)(?=\n\[|$)/);
+  if (!table?.groups?.body) {
+    return void 0;
+  }
+  const command = matchTomlString(table.groups.body, "command");
+  const args = matchTomlArray(table.groups.body, "args");
+  if (!command || !args) {
+    return void 0;
+  }
+  return { command, args };
+}
+function matchTomlString(body, key) {
+  const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const match = body.match(new RegExp(`^${escaped}\\s*=\\s*"(?<value>(?:[^"\\\\]|\\\\.)*)"\\s*$`, "m"));
+  return match?.groups?.value?.replace(/\\"/g, '"').replace(/\\\\/g, "\\");
+}
+function matchTomlArray(body, key) {
+  const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const match = body.match(new RegExp(`^${escaped}\\s*=\\s*\\[(?<value>.*)\\]\\s*$`, "m"));
+  if (!match?.groups?.value) {
+    return void 0;
+  }
+  const values = [];
+  const pattern = /"((?:[^"\\]|\\.)*)"/g;
+  let value;
+  while (value = pattern.exec(match.groups.value)) {
+    values.push(value[1].replace(/\\"/g, '"').replace(/\\\\/g, "\\"));
+  }
+  return values;
+}
+async function commandExists2(command) {
+  if (path14.isAbsolute(command) || command.includes(path14.sep)) {
+    try {
+      await access(command, constants.X_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  const paths = (process.env.PATH ?? "").split(path14.delimiter).filter(Boolean);
+  for (const dir of paths) {
+    try {
+      await access(path14.join(dir, command), constants.X_OK);
+      return true;
+    } catch {
+    }
+  }
+  return false;
+}
+async function checkCodexMcp(input2) {
+  const configPath = codexConfigPath2(input2.home);
+  const entry = await readCodexThreadrootMcpEntry(input2.home);
+  if (!entry) {
+    return {
+      status: "warning",
+      configPath,
+      tools: [],
+      messages: ["No Codex Threadroot MCP config found."]
+    };
+  }
+  if (!await commandExists2(entry.command)) {
+    return {
+      status: "error",
+      configPath,
+      entry,
+      tools: [],
+      messages: [`MCP command is not executable or not on PATH: ${entry.command}`]
+    };
+  }
+  try {
+    const handshake = await runMcpHandshake(entry, input2.repoRoot, input2.timeoutMs ?? 4e3);
+    const toolNames = handshake.tools;
+    const missing = REQUIRED_MCP_TOOLS.filter((tool) => !toolNames.includes(tool));
+    if (missing.length > 0) {
+      return {
+        status: "error",
+        configPath,
+        entry,
+        serverInfo: handshake.serverInfo,
+        tools: toolNames,
+        messages: [`MCP server is missing required tool(s): ${missing.join(", ")}`]
+      };
+    }
+    return {
+      status: "ok",
+      configPath,
+      entry,
+      serverInfo: handshake.serverInfo,
+      tools: toolNames,
+      messages: ["MCP server initialized and returned the expected Threadroot tools."]
+    };
+  } catch (error) {
+    return {
+      status: "error",
+      configPath,
+      entry,
+      tools: [],
+      messages: [`MCP handshake failed: ${error instanceof Error ? error.message : String(error)}`]
+    };
+  }
+}
+function runMcpHandshake(entry, repoRoot, timeoutMs) {
+  if (process.platform !== "win32") {
+    return runOneShotMcpHandshake(entry, repoRoot, timeoutMs);
+  }
+  return new Promise((resolve, reject) => {
+    const child = spawn2(entry.command, entry.args, {
+      cwd: repoRoot,
+      stdio: ["pipe", "pipe", "pipe"],
+      env: process.env
+    });
+    let settled = false;
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      child.kill();
+      resolve(result);
+    };
+    const fail = (error) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      child.kill();
+      reject(error);
+    };
+    const timer = setTimeout(() => {
+      fail(new Error(`Timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+    let stdout = "";
+    let stderr = "";
+    let initialized = false;
+    let serverInfo;
+    child.stdout.setEncoding("utf8");
+    child.stderr.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk;
+      const lines = stdout.split("\n");
+      stdout = lines.pop() ?? "";
+      for (const line of lines) {
+        if (!line.trim()) {
+          continue;
+        }
+        let message;
+        try {
+          message = JSON.parse(line);
+        } catch (error) {
+          fail(new Error(`Invalid JSON-RPC response: ${error instanceof Error ? error.message : String(error)}`));
+          return;
+        }
+        if (message.error) {
+          fail(new Error(message.error.message ?? "MCP server returned an error"));
+          return;
+        }
+        if (message.id === 1) {
+          initialized = true;
+          serverInfo = message.result?.serverInfo;
+          child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized" })}
+`);
+          child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", id: 2, method: "tools/list" })}
+`);
+        }
+        if (message.id === 2) {
+          finish({
+            serverInfo,
+            tools: (message.result?.tools ?? []).map((tool) => tool.name)
+          });
+        }
+      }
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    child.on("error", (error) => {
+      fail(error);
+    });
+    child.on("close", (code) => {
+      if (!settled && !initialized && code !== null) {
+        fail(new Error(`Server exited before initialize completed (exit ${code})${stderr ? `: ${stderr}` : ""}`));
+      }
+    });
+    child.stdin.write(
+      `${JSON.stringify({
+        jsonrpc: "2.0",
+        id: 1,
+        method: "initialize",
+        params: {
+          protocolVersion: "2024-11-05",
+          capabilities: {},
+          clientInfo: { name: "threadroot-check", version: THREADROOT_VERSION }
+        }
+      })}
+`
+    );
+  });
+}
+async function runOneShotMcpHandshake(entry, repoRoot, timeoutMs) {
+  const tempDir = await mkdtemp(path14.join(tmpdir(), "threadroot-mcp-check-"));
+  const inputPath = path14.join(tempDir, "input.jsonl");
+  const stdoutPath = path14.join(tempDir, "stdout.jsonl");
+  const stderrPath = path14.join(tempDir, "stderr.txt");
+  try {
+    await writeFile6(
+      inputPath,
+      [
+        JSON.stringify({
+          jsonrpc: "2.0",
+          id: 1,
+          method: "initialize",
+          params: {
+            protocolVersion: "2024-11-05",
+            capabilities: {},
+            clientInfo: { name: "threadroot-check", version: THREADROOT_VERSION }
+          }
+        }),
+        JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized" }),
+        JSON.stringify({ jsonrpc: "2.0", id: 2, method: "tools/list" }),
+        ""
+      ].join("\n"),
+      "utf8"
+    );
+    const commandLine = [
+      shellQuote3(entry.command),
+      ...entry.args.map(shellQuote3),
+      "<",
+      shellQuote3(inputPath),
+      ">",
+      shellQuote3(stdoutPath),
+      "2>",
+      shellQuote3(stderrPath)
+    ].join(" ");
+    await runShell(commandLine, repoRoot, timeoutMs);
+    const [stdout, stderr] = await Promise.all([readFile8(stdoutPath, "utf8"), readOptional(stderrPath)]);
+    if (stderr.trim()) {
+      throw new Error(stderr.trim());
+    }
+    return parseHandshakeOutput(stdout);
+  } finally {
+    await rm2(tempDir, { recursive: true, force: true });
+  }
+}
+function runShell(commandLine, repoRoot, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const child = spawn2("sh", ["-c", commandLine], {
+      cwd: repoRoot,
+      stdio: "ignore",
+      env: process.env
+    });
+    let settled = false;
+    const fail = (error) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      child.kill();
+      reject(error);
+    };
+    const timer = setTimeout(() => fail(new Error(`Timed out after ${timeoutMs}ms`)), timeoutMs);
+    child.on("error", fail);
+    child.on("close", async (code) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      if (code === 0) {
+        resolve();
+        return;
+      }
+      reject(new Error(`Server exited with status ${code ?? "unknown"}`));
+    });
+  });
+}
+function parseHandshakeOutput(stdout) {
+  let initialized = false;
+  let serverInfo;
+  let tools2;
+  for (const line of stdout.split("\n")) {
+    if (!line.trim()) {
+      continue;
+    }
+    let message;
+    try {
+      message = JSON.parse(line);
+    } catch (error) {
+      throw new Error(`Invalid JSON-RPC response: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (message.error) {
+      throw new Error(message.error.message ?? "MCP server returned an error");
+    }
+    if (message.id === 1) {
+      initialized = true;
+      serverInfo = message.result?.serverInfo;
+    }
+    if (message.id === 2) {
+      tools2 = (message.result?.tools ?? []).map((tool) => tool.name);
+    }
+  }
+  if (!initialized) {
+    throw new Error("Server did not return an initialize response");
+  }
+  if (!tools2) {
+    throw new Error("Server did not return a tools/list response");
+  }
+  return { serverInfo, tools: tools2 };
+}
+async function readOptional(filePath) {
+  try {
+    return await readFile8(filePath, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return "";
+    }
+    throw error;
+  }
+}
+function shellQuote3(value) {
+  return `'${value.replace(/'/g, "'\\''")}'`;
+}
+
 // src/core/doctor.ts
 async function exists3(filePath) {
   try {
@@ -2405,9 +2792,23 @@ async function exists3(filePath) {
 function finding2(severity, code, message, pathValue) {
   return pathValue ? { severity, code, message, path: pathValue } : { severity, code, message };
 }
-async function mcpConfigHints(repoRoot) {
+async function mcpConfigHints(repoRoot, home) {
+  const codexMcp = await checkCodexMcp({ repoRoot, home, timeoutMs: 2500 });
+  if (codexMcp.status === "ok") {
+    return [];
+  }
+  if (codexMcp.status === "error") {
+    return [
+      finding2(
+        "warning",
+        "codex_mcp_unhealthy",
+        `Codex Threadroot MCP is configured but failed verification: ${codexMcp.messages.join(" ")}`,
+        codexMcp.configPath
+      )
+    ];
+  }
   const configs = [".vscode/mcp.json", ".cursor/mcp.json", ".mcp.json"];
-  const present = await Promise.all(configs.map((config) => exists3(path14.join(repoRoot, config))));
+  const present = await Promise.all(configs.map((config) => exists3(path15.join(repoRoot, config))));
   if (present.some(Boolean)) {
     return [];
   }
@@ -2581,7 +2982,7 @@ async function doctor(repoRoot, options = {}) {
         )
       );
     }
-    const scriptsDir = path14.join(path14.dirname(skill.sourcePath), "scripts");
+    const scriptsDir = path15.join(path15.dirname(skill.sourcePath), "scripts");
     if (await exists3(scriptsDir)) {
       findings.push(
         finding2(
@@ -2594,7 +2995,7 @@ async function doctor(repoRoot, options = {}) {
     }
   }
   findings.push(...await globalSetupHints(options.home));
-  findings.push(...await mcpConfigHints(repoRoot));
+  findings.push(...await mcpConfigHints(repoRoot, options.home));
   return summarize(findings);
 }
 function summarize(findings) {
@@ -2605,11 +3006,11 @@ function summarize(findings) {
 }
 
 // src/core/expose.ts
-import { mkdir as mkdir6, readFile as readFile8, rm as rm2, stat as stat6, writeFile as writeFile6 } from "fs/promises";
-import path15 from "path";
+import { mkdir as mkdir6, readFile as readFile9, rm as rm3, stat as stat6, writeFile as writeFile7 } from "fs/promises";
+import path16 from "path";
 async function readMaybe2(filePath) {
   try {
-    return await readFile8(filePath, "utf8");
+    return await readFile9(filePath, "utf8");
   } catch (error) {
     if (error.code === "ENOENT") {
       return void 0;
@@ -2618,10 +3019,10 @@ async function readMaybe2(filePath) {
   }
 }
 function projectSkillPath(repoRoot, provider) {
-  return path15.join(repoRoot, provider.projectSkillDir, THREADROOT_SKILL_NAME, "SKILL.md");
+  return path16.join(repoRoot, provider.projectSkillDir, THREADROOT_SKILL_NAME, "SKILL.md");
 }
 function relSkillPath(provider) {
-  return path15.join(provider.projectSkillDir, THREADROOT_SKILL_NAME, "SKILL.md");
+  return path16.join(provider.projectSkillDir, THREADROOT_SKILL_NAME, "SKILL.md");
 }
 async function exposeOne(repoRoot, provider, mode, force) {
   const relativePath = relSkillPath(provider);
@@ -2653,7 +3054,7 @@ async function exposeOne(repoRoot, provider, mode, force) {
         message: "Existing skill is not Threadroot-managed."
       };
     }
-    await rm2(path15.dirname(absolutePath), { recursive: true, force: true });
+    await rm3(path16.dirname(absolutePath), { recursive: true, force: true });
     return { agent: provider.id, label: provider.label, path: relativePath, status: "removed" };
   }
   if (existing === desired) {
@@ -2672,8 +3073,8 @@ async function exposeOne(repoRoot, provider, mode, force) {
   if (mode === "dry-run") {
     return { agent: provider.id, label: provider.label, path: relativePath, status };
   }
-  await mkdir6(path15.dirname(absolutePath), { recursive: true });
-  await writeFile6(absolutePath, desired, "utf8");
+  await mkdir6(path16.dirname(absolutePath), { recursive: true });
+  await writeFile7(absolutePath, desired, "utf8");
   return { agent: provider.id, label: provider.label, path: relativePath, status };
 }
 async function exposeProject(repoRoot, options = {}) {
@@ -2687,18 +3088,18 @@ async function exposeProject(repoRoot, options = {}) {
 }
 
 // src/core/init/index.ts
-import { mkdir as mkdir9, stat as stat8, writeFile as writeFile8 } from "fs/promises";
-import path21 from "path";
+import { mkdir as mkdir9, stat as stat8, writeFile as writeFile9 } from "fs/promises";
+import path22 from "path";
 
 // src/core/compile/write.ts
-import { mkdir as mkdir7, writeFile as writeFile7 } from "fs/promises";
-import path16 from "path";
+import { mkdir as mkdir7, writeFile as writeFile8 } from "fs/promises";
+import path17 from "path";
 async function writeCompiled(repoRoot, files) {
   await Promise.all(
     files.map(async (file) => {
-      const absolute = path16.join(repoRoot, file.path);
-      await mkdir7(path16.dirname(absolute), { recursive: true });
-      await writeFile7(absolute, file.content, "utf8");
+      const absolute = path17.join(repoRoot, file.path);
+      await mkdir7(path17.dirname(absolute), { recursive: true });
+      await writeFile8(absolute, file.content, "utf8");
     })
   );
   return files.map((file) => file.path);
@@ -2714,7 +3115,7 @@ async function runCompile(repoRoot, options = {}) {
 
 // src/core/scan/package.ts
 import fs from "fs/promises";
-import path17 from "path";
+import path18 from "path";
 
 // src/core/scan/rules.ts
 var ignoredDirectories = /* @__PURE__ */ new Set([
@@ -2732,13 +3133,13 @@ var ignoredDirectories = /* @__PURE__ */ new Set([
 // src/core/scan/package.ts
 async function readJson(repoRoot, relativePath) {
   try {
-    return JSON.parse(await fs.readFile(path17.join(repoRoot, relativePath), "utf8"));
+    return JSON.parse(await fs.readFile(path18.join(repoRoot, relativePath), "utf8"));
   } catch {
     return void 0;
   }
 }
 function inferProfile(files, packageJson) {
-  if (files.some((file) => path17.basename(file) === "dbt_project.yml" || path17.basename(file) === "dbt_project.yaml")) {
+  if (files.some((file) => path18.basename(file) === "dbt_project.yml" || path18.basename(file) === "dbt_project.yaml")) {
     return "dbt";
   }
   const packageMeta = packageJson && typeof packageJson === "object" ? packageJson : void 0;
@@ -2763,9 +3164,9 @@ function inferProfile(files, packageJson) {
 
 // src/core/scan/walk.ts
 import fs2 from "fs/promises";
-import path18 from "path";
+import path19 from "path";
 function toPosix(relativePath) {
-  return relativePath.split(path18.sep).join("/");
+  return relativePath.split(path19.sep).join("/");
 }
 async function walkRepo(repoRoot, directory = repoRoot) {
   let entries;
@@ -2776,8 +3177,8 @@ async function walkRepo(repoRoot, directory = repoRoot) {
   }
   const files = [];
   for (const entry of entries) {
-    const absolutePath = path18.join(directory, entry.name);
-    const relativePath = toPosix(path18.relative(repoRoot, absolutePath));
+    const absolutePath = path19.join(directory, entry.name);
+    const relativePath = toPosix(path19.relative(repoRoot, absolutePath));
     if (entry.isDirectory()) {
       if (!ignoredDirectories.has(entry.name)) {
         files.push(...await walkRepo(repoRoot, absolutePath));
@@ -2796,16 +3197,16 @@ import { stringify as stringifyYaml4 } from "yaml";
 
 // src/core/init/builtins.ts
 import { cp, mkdir as mkdir8, readdir as readdir3, stat as stat7 } from "fs/promises";
-import path19 from "path";
+import path20 from "path";
 import { fileURLToPath } from "url";
-var DIST_DIR = path19.dirname(fileURLToPath(import.meta.url));
-var PACKAGE_ROOT_FROM_BUNDLE = path19.resolve(DIST_DIR, "..");
-var PACKAGE_ROOT_FROM_DIST = path19.resolve(DIST_DIR, "../../..");
-var PACKAGE_ROOT_FROM_SRC = path19.resolve(DIST_DIR, "../../../..");
+var DIST_DIR = path20.dirname(fileURLToPath(import.meta.url));
+var PACKAGE_ROOT_FROM_BUNDLE = path20.resolve(DIST_DIR, "..");
+var PACKAGE_ROOT_FROM_DIST = path20.resolve(DIST_DIR, "../../..");
+var PACKAGE_ROOT_FROM_SRC = path20.resolve(DIST_DIR, "../../../..");
 var SKILL_PACK_CANDIDATES = [
-  path19.join(PACKAGE_ROOT_FROM_BUNDLE, "skills"),
-  path19.join(PACKAGE_ROOT_FROM_DIST, "skills"),
-  path19.join(PACKAGE_ROOT_FROM_SRC, "skills")
+  path20.join(PACKAGE_ROOT_FROM_BUNDLE, "skills"),
+  path20.join(PACKAGE_ROOT_FROM_DIST, "skills"),
+  path20.join(PACKAGE_ROOT_FROM_SRC, "skills")
 ];
 var PROJECT_MEMORY_TEMPLATE = [
   "# Project",
@@ -2842,13 +3243,13 @@ async function writeBuiltinSkills(repoRoot) {
     if (!entry.isDirectory()) {
       continue;
     }
-    const sourceSkill = path19.join(sourceDir, entry.name);
-    const sourceSkillFile = path19.join(sourceSkill, "SKILL.md");
+    const sourceSkill = path20.join(sourceDir, entry.name);
+    const sourceSkillFile = path20.join(sourceSkill, "SKILL.md");
     if (!await exists4(sourceSkill) || !await stat7(sourceSkillFile).then((info) => info.isFile()).catch(() => false)) {
       continue;
     }
-    const targetSkill = path19.join(targetDir, entry.name);
-    const targetSkillFile = path19.join(targetSkill, "SKILL.md");
+    const targetSkill = path20.join(targetDir, entry.name);
+    const targetSkillFile = path20.join(targetSkill, "SKILL.md");
     try {
       await cp(sourceSkill, targetSkill, { recursive: true, force: false, errorOnExist: true });
       written.push(targetSkillFile);
@@ -2862,14 +3263,14 @@ async function writeBuiltinSkills(repoRoot) {
 }
 
 // src/core/init/import.ts
-import { readFile as readFile9, readdir as readdir4 } from "fs/promises";
-import path20 from "path";
+import { readFile as readFile10, readdir as readdir4 } from "fs/promises";
+import path21 from "path";
 var PROSE_PRECEDENCE = ["AGENTS.md", "CLAUDE.md", ".github/copilot-instructions.md"];
 var CURSOR_RULES_DIR = ".cursor/rules";
 var NAME_RE4 = /^[a-z0-9][a-z0-9-]*$/;
 async function readIfExists2(filePath) {
   try {
-    return await readFile9(filePath, "utf8");
+    return await readFile10(filePath, "utf8");
   } catch (error) {
     if (error.code === "ENOENT") {
       return void 0;
@@ -2913,7 +3314,7 @@ function novelSections(canonical, other) {
   });
 }
 async function listCursorRules(repoRoot) {
-  const dir = path20.join(repoRoot, CURSOR_RULES_DIR);
+  const dir = path21.join(repoRoot, CURSOR_RULES_DIR);
   let entries;
   try {
     entries = await readdir4(dir);
@@ -2927,7 +3328,7 @@ async function listCursorRules(repoRoot) {
   return Promise.all(
     files.map(async (name) => ({
       file: `${CURSOR_RULES_DIR}/${name}`,
-      content: await readFile9(path20.join(dir, name), "utf8")
+      content: await readFile10(path21.join(dir, name), "utf8")
     }))
   );
 }
@@ -2942,7 +3343,7 @@ function globsToApplyTo(value) {
   return void 0;
 }
 function ruleName(fileName) {
-  const base = path20.basename(fileName, ".mdc").toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "");
+  const base = path21.basename(fileName, ".mdc").toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "");
   return NAME_RE4.test(base) ? base : "imported-rule";
 }
 async function importVendorFiles(repoRoot, options = {}) {
@@ -2953,7 +3354,7 @@ async function importVendorFiles(repoRoot, options = {}) {
     if (!wanted(file)) {
       continue;
     }
-    const content = await readIfExists2(path20.join(repoRoot, file));
+    const content = await readIfExists2(path21.join(repoRoot, file));
     if (content && content.trim()) {
       prose.push({ file, content });
     }
@@ -3028,7 +3429,7 @@ async function detectName(repoRoot) {
   if (packageJson && typeof packageJson.name === "string" && packageJson.name.trim()) {
     return packageJson.name.trim();
   }
-  return path21.basename(repoRoot);
+  return path22.basename(repoRoot);
 }
 async function writeManifest(repoRoot, manifest) {
   const body = {
@@ -3041,14 +3442,14 @@ async function writeManifest(repoRoot, manifest) {
     body.tools = { allow: manifest.tools.allow };
   }
   await mkdir9(projectHarnessDir(repoRoot), { recursive: true });
-  await writeFile8(projectManifestPath(repoRoot), stringifyYaml4(body), "utf8");
+  await writeFile9(projectManifestPath(repoRoot), stringifyYaml4(body), "utf8");
 }
 async function writeProjectMemory(repoRoot) {
   const dir = projectObjectDir(repoRoot, "memory");
   await mkdir9(dir, { recursive: true });
-  const filePath = path21.join(dir, "project.md");
+  const filePath = path22.join(dir, "project.md");
   try {
-    await writeFile8(filePath, `${PROJECT_MEMORY_TEMPLATE}
+    await writeFile9(filePath, `${PROJECT_MEMORY_TEMPLATE}
 `, { encoding: "utf8", flag: "wx" });
     return [filePath];
   } catch (error) {
@@ -3066,13 +3467,13 @@ async function writeImportedRules(repoRoot, report) {
   await mkdir9(dir, { recursive: true });
   const written = [];
   for (const rule of report.importedRules) {
-    const filePath = path21.join(dir, `${rule.name}.md`);
+    const filePath = path22.join(dir, `${rule.name}.md`);
     const data = { name: rule.name, scope: "project" };
     if (rule.applyTo) {
       data.applyTo = rule.applyTo;
     }
     try {
-      await writeFile8(filePath, serializeFrontmatter(data, rule.body), { encoding: "utf8", flag: "wx" });
+      await writeFile9(filePath, serializeFrontmatter(data, rule.body), { encoding: "utf8", flag: "wx" });
       written.push(filePath);
     } catch (error) {
       if (error.code !== "EEXIST") {
@@ -3111,7 +3512,7 @@ async function writeStarterTools(repoRoot, profile, force) {
 async function initHarness(repoRoot, options = {}) {
   if (!options.force && await pathExists(projectManifestPath(repoRoot))) {
     throw new InitError(
-      `A harness already exists at ${path21.join(".threadroot", "harness.yaml")}. Re-run with --force to overwrite.`
+      `A harness already exists at ${path22.join(".threadroot", "harness.yaml")}. Re-run with --force to overwrite.`
     );
   }
   const profile = await detectProfile(repoRoot, options.profile);
@@ -3133,7 +3534,7 @@ async function initHarness(repoRoot, options = {}) {
   if (options.import !== false) {
     report = await importVendorFiles(repoRoot, { include: options.importFiles });
     if (report.canonicalBody.trim()) {
-      await writeFile8(path21.join(repoRoot, AGENTS_FILE2), `${report.canonicalBody.trim()}
+      await writeFile9(path22.join(repoRoot, AGENTS_FILE2), `${report.canonicalBody.trim()}
 `, "utf8");
     }
     rules = await writeImportedRules(repoRoot, report);
@@ -3177,7 +3578,7 @@ async function harnessStatus(repoRoot, options = {}) {
 // src/core/bootstrap.ts
 var DEFAULT_TASK = "start this project";
 async function harnessExists(repoRoot) {
-  return pathExists2(path22.join(repoRoot, ".threadroot", "harness.yaml"));
+  return pathExists2(path23.join(repoRoot, ".threadroot", "harness.yaml"));
 }
 async function pathExists2(target) {
   try {
@@ -3207,7 +3608,8 @@ async function bootstrapProject(repoRoot, options = {}) {
       agents: options.agents ?? "all",
       mode,
       home: options.home,
-      mcp: options.mcp
+      mcp: options.mcp,
+      mcpEntry: options.mcpEntry
     });
   } else {
     notes.push("Skipped global setup because --no-global was set.");
@@ -3220,14 +3622,14 @@ async function bootstrapProject(repoRoot, options = {}) {
         home: options.home
       });
     } else {
-      notes.push(`Would initialize local-only harness at ${path22.join(".threadroot", "harness.yaml")}.`);
+      notes.push(`Would initialize local-only harness at ${path23.join(".threadroot", "harness.yaml")}.`);
     }
   } else if (existed) {
     notes.push("Existing harness detected; bootstrap will not reinitialize it.");
   } else {
     notes.push("Skipped project initialization because --no-init was set.");
   }
-  const hasHarnessAfterInit = existed || Boolean(init) || await pathExists2(path22.join(repoRoot, ".threadroot", "harness.yaml"));
+  const hasHarnessAfterInit = existed || Boolean(init) || await pathExists2(path23.join(repoRoot, ".threadroot", "harness.yaml"));
   if (options.expose) {
     exposed = await exposeProject(repoRoot, {
       agents: options.expose,
@@ -3237,6 +3639,10 @@ async function bootstrapProject(repoRoot, options = {}) {
   let status;
   let doctorReport;
   let context;
+  let mcpCheck;
+  if (options.mcp && write2) {
+    mcpCheck = await checkCodexMcp({ repoRoot, home: options.home });
+  }
   if (hasHarnessAfterInit) {
     status = await harnessStatus(repoRoot, { home: options.home });
     doctorReport = await doctor(repoRoot, { home: options.home });
@@ -3259,6 +3665,7 @@ async function bootstrapProject(repoRoot, options = {}) {
     status,
     doctor: doctorReport,
     context,
+    mcpCheck,
     notes
   };
 }
@@ -3341,6 +3748,18 @@ function printCommandMap() {
   console.log("- `threadroot tools list|check` and `threadroot run <tool>` - use explicit local tools");
   console.log('- `threadroot remember "<note>"` - save durable handoff/project memory');
 }
+function printMcpCheck(report) {
+  if (!report) {
+    return;
+  }
+  console.log(`mcp check: ${report.status}`);
+  if (report.entry) {
+    console.log(`mcp server: ${report.entry.command} ${report.entry.args.join(" ")}`.trim());
+  }
+  for (const message of report.messages) {
+    console.log(`- ${message}`);
+  }
+}
 function printBootstrapReport(report) {
   console.log(`Threadroot bootstrap: ${report.mode === "write" ? "complete" : "plan"}`);
   if (report.setup) {
@@ -3363,6 +3782,7 @@ function printBootstrapReport(report) {
     }
   }
   printStatus(report.status);
+  printMcpCheck(report.mcpCheck);
   printDoctor(report.doctor);
   printContext(report.context);
   printCommandMap();
@@ -3396,7 +3816,8 @@ async function runBootstrap(repoRoot, options) {
     noGlobal: options.global === false,
     noInit: options.init === false,
     import: options.import,
-    profile: options.profile ? profileIdSchema.parse(options.profile) : void 0
+    profile: options.profile ? profileIdSchema.parse(options.profile) : void 0,
+    mcpEntry: options.mcp ? mcpEntryForCurrentProcess() : void 0
   });
   printBootstrapReport(report);
   if (report.mode === "write" && report.doctor && !report.doctor.ok) {
@@ -3468,7 +3889,7 @@ async function runContext(repoRoot, task) {
 
 // src/commands/diff.ts
 import fs3 from "fs/promises";
-import path23 from "path";
+import path24 from "path";
 async function readIfExists3(filePath) {
   try {
     return await fs3.readFile(filePath, "utf8");
@@ -3527,7 +3948,7 @@ async function runDiff(repoRoot) {
   const files = await compile(repoRoot, harness);
   let changed = 0;
   for (const file of files) {
-    const existing = await readIfExists3(path23.join(repoRoot, file.path));
+    const existing = await readIfExists3(path24.join(repoRoot, file.path));
     if (existing === void 0) {
       changed += 1;
       console.log(`+ ${file.path} (new)`);
@@ -3642,13 +4063,13 @@ async function runInit(repoRoot, options) {
 }
 
 // src/commands/install.ts
-import path26 from "path";
+import path27 from "path";
 
 // src/core/install/fetch.ts
 import { execFile } from "child_process";
-import { mkdtemp, rm as rm3 } from "fs/promises";
+import { mkdtemp as mkdtemp2, rm as rm4 } from "fs/promises";
 import os2 from "os";
-import path24 from "path";
+import path25 from "path";
 import { promisify } from "util";
 var run = promisify(execFile);
 function cloneUrl(ref) {
@@ -3669,8 +4090,8 @@ async function git(cwd, args) {
 }
 async function fetchGitSource(ref) {
   const url = cloneUrl(ref);
-  const dir = await mkdtemp(path24.join(os2.tmpdir(), "threadroot-fetch-"));
-  const cleanup = () => rm3(dir, { recursive: true, force: true });
+  const dir = await mkdtemp2(path25.join(os2.tmpdir(), "threadroot-fetch-"));
+  const cleanup = () => rm4(dir, { recursive: true, force: true });
   try {
     if (ref.ref) {
       try {
@@ -3691,9 +4112,9 @@ async function fetchGitSource(ref) {
 }
 
 // src/core/install/install.ts
-import { cp as cp2, mkdir as mkdir10, readFile as readFile10, readdir as readdir5, stat as stat10, writeFile as writeFile9 } from "fs/promises";
+import { cp as cp2, mkdir as mkdir10, readFile as readFile11, readdir as readdir5, stat as stat10, writeFile as writeFile10 } from "fs/promises";
 import { createHash as createHash2 } from "crypto";
-import path25 from "path";
+import path26 from "path";
 var NAME_RE5 = /^[a-z0-9][a-z0-9-]*$/;
 var KIND_DIR = {
   skill: "skills",
@@ -3705,8 +4126,8 @@ function objectExt(kind) {
   return kind === "tool" || kind === "connection" ? ".yaml" : ".md";
 }
 function safeRepoPath(objectPath) {
-  const normalized = path25.normalize(objectPath);
-  if (path25.isAbsolute(normalized) || normalized === ".." || normalized.startsWith(`..${path25.sep}`)) {
+  const normalized = path26.normalize(objectPath);
+  if (path26.isAbsolute(normalized) || normalized === ".." || normalized.startsWith(`..${path26.sep}`)) {
     throw new Error(`Unsafe object path: ${objectPath}`);
   }
   return normalized;
@@ -3720,7 +4141,7 @@ function inferKind(objectPath, override) {
   if (segments.includes("tools")) return "tool";
   if (segments.includes("connections")) return "connection";
   if (segments.includes("rules")) return "rule";
-  const ext = path25.extname(objectPath).toLowerCase();
+  const ext = path26.extname(objectPath).toLowerCase();
   if (ext === ".yaml" || ext === ".yml") return "tool";
   if (ext === ".md") return "skill";
   throw new Error(
@@ -3728,7 +4149,7 @@ function inferKind(objectPath, override) {
   );
 }
 function deriveName(objectPath) {
-  const base = path25.basename(objectPath, path25.extname(objectPath));
+  const base = path26.basename(objectPath, path26.extname(objectPath));
   if (!NAME_RE5.test(base)) {
     throw new Error(`Invalid object name \`${base}\` (use lowercase letters, digits, and dashes).`);
   }
@@ -3740,8 +4161,8 @@ async function hashDirectory(root) {
   async function walk(dir) {
     const entries = (await readdir5(dir, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name));
     for (const entry of entries) {
-      const full = path25.join(dir, entry.name);
-      const rel = path25.relative(root, full).split(path25.sep).join("/");
+      const full = path26.join(dir, entry.name);
+      const rel = path26.relative(root, full).split(path26.sep).join("/");
       if (entry.isSymbolicLink()) {
         throw new Error(`Refusing to install skill directory with symlink: ${rel}`);
       }
@@ -3752,7 +4173,7 @@ async function hashDirectory(root) {
       if (entry.isFile()) {
         hash.update(`file:${rel}
 `);
-        hash.update(await readFile10(full));
+        hash.update(await readFile11(full));
         hash.update("\n");
       }
     }
@@ -3761,8 +4182,8 @@ async function hashDirectory(root) {
   return hash.digest("hex");
 }
 async function validateSkillDirectory2(sourcePath, expectedName) {
-  const skillPath = path25.join(sourcePath, "SKILL.md");
-  const parsed = parseFrontmatter(await readFile10(skillPath, "utf8"));
+  const skillPath = path26.join(sourcePath, "SKILL.md");
+  const parsed = parseFrontmatter(await readFile11(skillPath, "utf8"));
   const result = skillFrontmatterSchema.safeParse(parsed.data);
   if (!result.success) {
     const detail = result.error.issues.map((issue) => issue.message).join("; ");
@@ -3791,7 +4212,7 @@ async function installObject(repoRoot, rawSource, options = {}) {
     objectPath = safeRepoPath(within);
     refLabel = ref.ref;
     const fetched = await fetchGitSource(ref);
-    sourcePath = path25.join(fetched.dir, objectPath);
+    sourcePath = path26.join(fetched.dir, objectPath);
     resolved = fetched.sha;
     cleanup = fetched.cleanup;
   } else {
@@ -3812,14 +4233,14 @@ async function installObject(repoRoot, rawSource, options = {}) {
         throw new Error("Only skill objects may be installed from a directory.");
       }
       integrity = `sha256:${await validateSkillDirectory2(sourcePath, name)}`;
-      destPath = path25.join(destDir, name);
+      destPath = path26.join(destDir, name);
       await mkdir10(destDir, { recursive: true });
       await cp2(sourcePath, destPath, { recursive: true, force: true });
     } else {
-      const content = await readFile10(sourcePath, "utf8");
-      destPath = path25.join(destDir, `${name}${objectExt(kind)}`);
+      const content = await readFile11(sourcePath, "utf8");
+      destPath = path26.join(destDir, `${name}${objectExt(kind)}`);
       await mkdir10(destDir, { recursive: true });
-      await writeFile9(destPath, content, "utf8");
+      await writeFile10(destPath, content, "utf8");
       integrity = `sha256:${hashContent(content)}`;
     }
     const entry = {
@@ -3871,7 +4292,7 @@ async function runInstall(repoRoot, source, options) {
     if (installed.kind === "skill" && installed.entry.sourceKind !== "local") {
       console.log("  note: inspect external skills before trusting bundled scripts, assets, or allowed tools.");
       if (scope === "project") {
-        console.log(`  inspect: threadroot skills inspect ${path26.relative(repoRoot, installed.path)}`);
+        console.log(`  inspect: threadroot skills inspect ${path27.relative(repoRoot, installed.path)}`);
       }
     }
   } catch (error) {
@@ -4162,8 +4583,9 @@ async function handleMessage(repoRoot, request) {
     if (request.method === "initialize") {
       return resultResponse(request, {
         protocolVersion: "2024-11-05",
-        serverInfo: { name: "threadroot", version: "0.1.2" },
-        capabilities: { tools: {} }
+        serverInfo: { name: "threadroot", version: THREADROOT_VERSION },
+        capabilities: { tools: {} },
+        instructions: "Threadroot exposes the repository's AI agent harness. Call `context` before broad coding work, `doctor` for health and trust checks, inspect skills/tools before risky actions, and use `memory_append` for durable handoffs."
       });
     }
     if (request.method === "notifications/initialized") {
@@ -4385,11 +4807,11 @@ function agentNotes(agent) {
 }
 
 // src/core/mcp-config.ts
-import { mkdir as mkdir11, readFile as readFile11, writeFile as writeFile10 } from "fs/promises";
-import path27 from "path";
+import { mkdir as mkdir11, readFile as readFile12, writeFile as writeFile11 } from "fs/promises";
+import path28 from "path";
 var TARGETS = [
-  { agent: "copilot", file: path27.join(".vscode", "mcp.json"), key: "servers" },
-  { agent: "cursor", file: path27.join(".cursor", "mcp.json"), key: "mcpServers" },
+  { agent: "copilot", file: path28.join(".vscode", "mcp.json"), key: "servers" },
+  { agent: "cursor", file: path28.join(".cursor", "mcp.json"), key: "mcpServers" },
   { agent: "claude", file: ".mcp.json", key: "mcpServers" }
 ];
 function mcpServerEntry(command, scriptPath) {
@@ -4398,7 +4820,7 @@ function mcpServerEntry(command, scriptPath) {
 async function mergeConfig(filePath, key, entry) {
   let config = {};
   try {
-    const raw = await readFile11(filePath, "utf8");
+    const raw = await readFile12(filePath, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed === "object") {
       config = parsed;
@@ -4411,8 +4833,8 @@ async function mergeConfig(filePath, key, entry) {
   const servers = config[key] && typeof config[key] === "object" ? config[key] : {};
   servers.threadroot = { ...entry };
   config[key] = servers;
-  await mkdir11(path27.dirname(filePath), { recursive: true });
-  await writeFile10(filePath, `${JSON.stringify(config, null, 2)}
+  await mkdir11(path28.dirname(filePath), { recursive: true });
+  await writeFile11(filePath, `${JSON.stringify(config, null, 2)}
 `, "utf8");
 }
 async function writeProjectMcpConfigs(input2) {
@@ -4420,7 +4842,7 @@ async function writeProjectMcpConfigs(input2) {
   const targets = agents ? TARGETS.filter((target) => agents.includes(target.agent)) : TARGETS;
   const written = [];
   for (const target of targets) {
-    const filePath = path27.join(input2.repoRoot, target.file);
+    const filePath = path28.join(input2.repoRoot, target.file);
     await mergeConfig(filePath, target.key, input2.entry);
     written.push(target.file);
   }
@@ -4454,6 +4876,24 @@ async function runMcpSetup(repoRoot, options) {
   }
   console.log(mcpSetupGuide({ repoRoot, agent: options.agent }));
 }
+async function runMcpCheck(repoRoot, options) {
+  const timeoutMs = options.timeout ? Number.parseInt(options.timeout, 10) : void 0;
+  const report = await checkCodexMcp({ repoRoot, timeoutMs });
+  console.log(`Threadroot MCP check: ${report.status}`);
+  console.log(`config: ${report.configPath}`);
+  if (report.entry) {
+    console.log(`server: ${report.entry.command} ${report.entry.args.join(" ")}`.trim());
+  }
+  for (const message of report.messages) {
+    console.log(`- ${message}`);
+  }
+  if (report.tools.length > 0) {
+    console.log(`tools: ${report.tools.join(", ")}`);
+  }
+  if (report.status === "error") {
+    process.exitCode = 1;
+  }
+}
 
 // src/commands/memory.ts
 async function runMemoryRead(repoRoot, type) {
@@ -4540,7 +4980,8 @@ async function runSetup(_repoRoot, options) {
     agents: options.agent,
     mode,
     force: options.force,
-    mcp: options.mcp
+    mcp: options.mcp,
+    mcpEntry: options.mcp ? mcpEntryForCurrentProcess() : void 0
   });
   const title = mode === "dry-run" ? "Global setup plan" : mode === "check" ? "Global setup check" : mode === "undo" ? "Global setup undo" : "Global setup complete";
   console.log(`${title}:`);
@@ -4548,6 +4989,19 @@ async function runSetup(_repoRoot, options) {
     const suffix = entry.message ? ` - ${entry.message}` : "";
     console.log(`- ${entry.label}: ${entry.status} ${entry.path}${suffix}`);
   }
+  if (options.mcp && options.global && mode === "write") {
+    const check = await checkCodexMcp({ repoRoot: _repoRoot });
+    console.log(`MCP verification: ${check.status}`);
+    if (check.entry) {
+      console.log(`MCP server: ${check.entry.command} ${check.entry.args.join(" ")}`.trim());
+    }
+    for (const message of check.messages) {
+      console.log(`- ${message}`);
+    }
+    if (check.status === "error") {
+      process.exitCode = 1;
+    }
+  }
   if (mode === "write") {
     console.log("Reload or restart open agent sessions so new global skills/config are discovered.");
   }
@@ -4586,8 +5040,8 @@ async function runStatus(repoRoot) {
 }
 
 // src/core/packs/index.ts
-import { cp as cp3, mkdir as mkdir12, readFile as readFile12, readdir as readdir6, stat as stat11 } from "fs/promises";
-import path28 from "path";
+import { cp as cp3, mkdir as mkdir12, readFile as readFile13, readdir as readdir6, stat as stat11 } from "fs/promises";
+import path29 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { parse as parseYaml3 } from "yaml";
 import { z as z5 } from "zod";
@@ -4600,14 +5054,14 @@ var packManifestSchema = z5.object({
   rules: z5.array(z5.string()).default([]),
   connections: z5.array(z5.string()).default([])
 });
-var DIST_DIR2 = path28.dirname(fileURLToPath2(import.meta.url));
-var PACKAGE_ROOT_FROM_BUNDLE2 = path28.resolve(DIST_DIR2, "..");
-var PACKAGE_ROOT_FROM_DIST2 = path28.resolve(DIST_DIR2, "../../..");
-var PACKAGE_ROOT_FROM_SRC2 = path28.resolve(DIST_DIR2, "../../../..");
+var DIST_DIR2 = path29.dirname(fileURLToPath2(import.meta.url));
+var PACKAGE_ROOT_FROM_BUNDLE2 = path29.resolve(DIST_DIR2, "..");
+var PACKAGE_ROOT_FROM_DIST2 = path29.resolve(DIST_DIR2, "../../..");
+var PACKAGE_ROOT_FROM_SRC2 = path29.resolve(DIST_DIR2, "../../../..");
 var PACK_CANDIDATES = [
-  path28.join(PACKAGE_ROOT_FROM_BUNDLE2, "packs"),
-  path28.join(PACKAGE_ROOT_FROM_DIST2, "packs"),
-  path28.join(PACKAGE_ROOT_FROM_SRC2, "packs")
+  path29.join(PACKAGE_ROOT_FROM_BUNDLE2, "packs"),
+  path29.join(PACKAGE_ROOT_FROM_DIST2, "packs"),
+  path29.join(PACKAGE_ROOT_FROM_SRC2, "packs")
 ];
 async function exists5(target) {
   try {
@@ -4639,22 +5093,22 @@ async function isPackRoot(candidate) {
     return false;
   }
   for (const entry of entries) {
-    if (entry.isDirectory() && await exists5(path28.join(candidate, entry.name, "pack.yaml"))) {
+    if (entry.isDirectory() && await exists5(path29.join(candidate, entry.name, "pack.yaml"))) {
       return true;
     }
   }
   return false;
 }
 function safeRelative(ref) {
-  const normalized = path28.normalize(ref);
-  if (path28.isAbsolute(normalized) || normalized === ".." || normalized.startsWith(`..${path28.sep}`)) {
+  const normalized = path29.normalize(ref);
+  if (path29.isAbsolute(normalized) || normalized === ".." || normalized.startsWith(`..${path29.sep}`)) {
     throw new Error(`Unsafe pack reference: ${ref}`);
   }
   return normalized;
 }
 async function readPackManifest(packDir) {
-  const file = path28.join(packDir, "pack.yaml");
-  const parsed = packManifestSchema.safeParse(parseYaml3(await readFile12(file, "utf8")));
+  const file = path29.join(packDir, "pack.yaml");
+  const parsed = packManifestSchema.safeParse(parseYaml3(await readFile13(file, "utf8")));
   if (!parsed.success) {
     const detail = parsed.error.issues.map((issue) => issue.message).join("; ");
     throw new Error(`Invalid pack manifest ${file}: ${detail}`);
@@ -4662,7 +5116,7 @@ async function readPackManifest(packDir) {
   return parsed.data;
 }
 async function packDirFor(repoRoot, nameOrPath) {
-  if (path28.isAbsolute(nameOrPath)) {
+  if (path29.isAbsolute(nameOrPath)) {
     return nameOrPath;
   }
   if (nameOrPath.startsWith(".") || nameOrPath.includes("/") || nameOrPath.includes("\\")) {
@@ -4670,14 +5124,14 @@ async function packDirFor(repoRoot, nameOrPath) {
   }
   const bundled = await bundledPacksDir();
   if (bundled) {
-    return path28.join(bundled, nameOrPath);
+    return path29.join(bundled, nameOrPath);
   }
-  return toRepoPath(repoRoot, path28.join("packs", nameOrPath));
+  return toRepoPath(repoRoot, path29.join("packs", nameOrPath));
 }
 async function directFiles(dir, ext) {
   try {
     const entries = await readdir6(dir, { withFileTypes: true });
-    return entries.filter((entry) => entry.isFile() && entry.name.endsWith(ext)).map((entry) => path28.join(dir, entry.name)).sort();
+    return entries.filter((entry) => entry.isFile() && entry.name.endsWith(ext)).map((entry) => path29.join(dir, entry.name)).sort();
   } catch (error) {
     if (error.code === "ENOENT") {
       return [];
@@ -4690,11 +5144,11 @@ async function skillEntries(dir) {
     const entries = await readdir6(dir, { withFileTypes: true });
     const result = [];
     for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
-      const full = path28.join(dir, entry.name);
+      const full = path29.join(dir, entry.name);
       if (entry.isFile() && entry.name.endsWith(".md")) {
         result.push(full);
       }
-      if (entry.isDirectory() && await exists5(path28.join(full, "SKILL.md"))) {
+      if (entry.isDirectory() && await exists5(path29.join(full, "SKILL.md"))) {
         result.push(full);
       }
     }
@@ -4709,34 +5163,34 @@ async function skillEntries(dir) {
 async function collectObjects(packDir, manifest) {
   async function resolveRef(ref) {
     const safe = safeRelative(ref);
-    const local = path28.resolve(packDir, safe);
+    const local = path29.resolve(packDir, safe);
     if (await exists5(local)) {
       return local;
     }
-    return path28.resolve(packDir, "..", "..", safe);
+    return path29.resolve(packDir, "..", "..", safe);
   }
   return {
     skills: [
       ...await Promise.all(manifest.skills.map(resolveRef)),
-      ...await skillEntries(path28.join(packDir, "skills"))
+      ...await skillEntries(path29.join(packDir, "skills"))
     ],
     tools: [
       ...await Promise.all(manifest.tools.map(resolveRef)),
-      ...await directFiles(path28.join(packDir, "tools"), ".yaml")
+      ...await directFiles(path29.join(packDir, "tools"), ".yaml")
     ],
     rules: [
       ...await Promise.all(manifest.rules.map(resolveRef)),
-      ...await directFiles(path28.join(packDir, "rules"), ".md")
+      ...await directFiles(path29.join(packDir, "rules"), ".md")
     ],
     connections: [
       ...await Promise.all(manifest.connections.map(resolveRef)),
-      ...await directFiles(path28.join(packDir, "connections"), ".yaml")
+      ...await directFiles(path29.join(packDir, "connections"), ".yaml")
     ]
   };
 }
 function baseName(source) {
-  const parsed = path28.basename(source) === "SKILL.md" ? path28.dirname(source) : source;
-  return path28.basename(parsed, path28.extname(parsed));
+  const parsed = path29.basename(source) === "SKILL.md" ? path29.dirname(source) : source;
+  return path29.basename(parsed, path29.extname(parsed));
 }
 async function listPacks(repoRoot) {
   const dirs = [toRepoPath(repoRoot, "packs"), await bundledPacksDir()].filter((dir) => Boolean(dir));
@@ -4753,8 +5207,8 @@ async function listPacks(repoRoot) {
       if (!entry.isDirectory() || seen.has(entry.name)) {
         continue;
       }
-      const packDir = path28.join(root, entry.name);
-      if (!await exists5(path28.join(packDir, "pack.yaml"))) {
+      const packDir = path29.join(root, entry.name);
+      if (!await exists5(path29.join(packDir, "pack.yaml"))) {
         continue;
       }
       seen.add(entry.name);
@@ -4778,14 +5232,14 @@ async function inspectPack(repoRoot, nameOrPath) {
   };
 }
 async function validateProse(file, kind) {
-  const target = path28.basename(file) === "SKILL.md" ? file : file;
-  const content = await readFile12(target, "utf8");
+  const target = path29.basename(file) === "SKILL.md" ? file : file;
+  const content = await readFile13(target, "utf8");
   const parsed = parseFrontmatter(content);
   const schema = kind === "skill" ? skillFrontmatterSchema : ruleFrontmatterSchema;
   schema.parse(parsed.data);
 }
 async function validateYaml(file, kind) {
-  const content = await readFile12(file, "utf8");
+  const content = await readFile13(file, "utf8");
   const schema = kind === "tool" ? toolManifestSchema : connectionManifestSchema;
   schema.parse(parseYaml3(content));
 }
@@ -4796,7 +5250,7 @@ async function validatePack(repoRoot, nameOrPath) {
     const manifest = await readPackManifest(packDir);
     const objects = await collectObjects(packDir, manifest);
     for (const skill of objects.skills) {
-      await validateProse(path28.basename(skill) === "SKILL.md" ? skill : path28.join(skill, "SKILL.md"), "skill");
+      await validateProse(path29.basename(skill) === "SKILL.md" ? skill : path29.join(skill, "SKILL.md"), "skill");
     }
     for (const rule of objects.rules) await validateProse(rule, "rule");
     for (const tool of objects.tools) await validateYaml(tool, "tool");
@@ -4812,7 +5266,7 @@ async function validatePack(repoRoot, nameOrPath) {
 async function copyObject(source, destDir) {
   const info = await stat11(source);
   const name = baseName(source);
-  const dest = info.isDirectory() ? path28.join(destDir, name) : path28.join(destDir, path28.basename(source));
+  const dest = info.isDirectory() ? path29.join(destDir, name) : path29.join(destDir, path29.basename(source));
   await mkdir12(destDir, { recursive: true });
   await cp3(source, dest, { recursive: true, force: true });
   return dest;
@@ -5101,7 +5555,7 @@ async function runConnectionsCheck(repoRoot) {
 // src/cli.ts
 function createProgram(repoRoot = process.cwd()) {
   const program = new Command();
-  program.name("threadroot").description("Git for your AI agent harness: one command to bootstrap, one .threadroot source.").version("0.1.2");
+  program.name("threadroot").description("Git for your AI agent harness: one command to bootstrap, one .threadroot source.").version(THREADROOT_VERSION);
   program.command("bootstrap").description("Plan or apply first-run Threadroot setup for this machine and repository.").option("-y, --yes", "Apply the setup plan. Without --yes, bootstrap prints a dry-run plan.").option("--dry-run", "Print the setup plan without writing files.").option("--agent <list>", "Provider(s): codex,claude,cursor,copilot,gemini,windsurf,antigravity,opencode,all.").option("--task <task>", "Task used for the initial context slice.").option("--mcp", "Also add Threadroot MCP to Codex global config when Codex is selected.").option("--expose <list>", "Also write project provider skill shims: codex,claude,cursor,copilot,gemini,windsurf,antigravity,opencode,all.").option("--no-global", "Skip one-time machine-level agent setup.").option("--no-init", "Skip project harness initialization.").option("--no-import", "Skip importing existing vendor files during init.").option("--profile <profile>", "Override the detected project profile during init.").action((options) => runBootstrap(repoRoot, options));
   program.command("start").argument("[task]", "Task to prepare context for.").option("--task <task>", "Task to prepare context for.").description("Start a focused Threadroot agent session: doctor, status, context, and command map.").action((task, options) => runStart(repoRoot, task, options));
   program.command("init").description("Scaffold a local-only Threadroot harness and import existing vendor files once.").option("--force", "Re-initialize over an existing harness.").option("--no-import", "Skip importing existing vendor files (blank-slate init).").option("--profile <profile>", "Override the detected project profile.").option("--adapters <list>", "Comma-separated adapters: agents,claude,copilot,cursor.").option("--expose <list>", "Comma-separated provider skill shims to write: codex,claude,cursor,copilot,gemini,windsurf,antigravity,opencode,all.").action((options) => runInit(repoRoot, options));
@@ -5139,6 +5593,7 @@ function createProgram(repoRoot = process.cwd()) {
   skills.command("validate").option("--path <path>", "Validate a repo-relative skill file, skill directory, or skill collection.").description("Validate skill frontmatter, naming, trigger descriptions, and progressive-disclosure hygiene.").action((options) => runSkillsValidate(repoRoot, options));
   const mcp = program.command("mcp").description("Run or configure the local Threadroot MCP server.");
   mcp.action(() => runMcp(repoRoot));
+  mcp.command("check").option("--timeout <ms>", "Handshake timeout in milliseconds.").description("Verify Codex MCP config and the Threadroot stdio server handshake.").action((options) => runMcpCheck(repoRoot, options));
   mcp.command("setup").option("--agent <agent>", "all, generic, codex, copilot, cursor, or claude.").option("--write", "Write project-local MCP config files for the agents.").description("Print MCP config snippets and a pasteable agent bootstrap prompt.").action((options) => runMcpSetup(repoRoot, options));
   return program;
 }