npm - threadroot - Versions diffs - 0.1.2 → 0.1.3 - Mend

threadroot 0.1.2 → 0.1.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (4) hide show

package/dist/index.js CHANGED Viewed

@@ -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,376 @@ 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";
+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() {
+  const scriptPath = currentScriptPath();
+  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() {
+  const scriptPath = process.argv[1];
+  if (!scriptPath) {
+    return void 0;
+  }
+  try {
+    return realpathSync(scriptPath);
+  } catch {
+    return scriptPath;
+  }
+}
+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: "0.1.3" }
+        }
+      })}
+`
+    );
+  });
+}
+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: "0.1.3" }
+          }
+        }),
+        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 +2778,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 +2968,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 +2981,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 +2992,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 +3005,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 +3040,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 +3059,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 +3074,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 +3101,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 +3119,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 +3150,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 +3163,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 +3183,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 +3229,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 +3249,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 +3300,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 +3314,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 +3329,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 +3340,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 +3415,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 +3428,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 +3453,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 +3498,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 +3520,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 +3564,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 +3594,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 +3608,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 +3625,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 +3651,7 @@ async function bootstrapProject(repoRoot, options = {}) {
     status,
     doctor: doctorReport,
     context,
+    mcpCheck,
     notes
   };
 }
@@ -3341,6 +3734,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 +3768,7 @@ function printBootstrapReport(report) {
     }
   }
   printStatus(report.status);
+  printMcpCheck(report.mcpCheck);
   printDoctor(report.doctor);
   printContext(report.context);
   printCommandMap();
@@ -3396,7 +3802,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 +3875,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 +3934,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 +4049,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 +4076,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 +4098,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 +4112,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 +4127,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 +4135,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 +4147,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 +4159,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 +4168,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 +4198,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 +4219,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 +4278,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 +4569,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: "0.1.3" },
+        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 +4793,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 +4806,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 +4819,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 +4828,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 +4862,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 +4966,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 +4975,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 +5026,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 +5040,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 +5079,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 +5102,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 +5110,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 +5130,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 +5149,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 +5193,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 +5218,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 +5236,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 +5252,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 +5541,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("0.1.3");
   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 +5579,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;
 }