@arvoretech/hub 0.9.0 → 0.11.0

package/dist/{chunk-NUJMJOEK.js → chunk-MDJG7IOU.js}

@@ -1,43 +1,37 @@
+import {
+  loadHubConfig
+} from "./chunk-VMN4KGAK.js";
+
 // src/commands/generate.ts
 import { Command } from "commander";
 import { existsSync as existsSync2 } from "fs";
-import { mkdir as mkdir3, writeFile as writeFile3, readdir as readdir2, copyFile, readFile as readFile4, cp } from "fs/promises";
-import { join as join4, resolve as resolve2 } from "path";
+import { mkdir as mkdir3, writeFile as writeFile3, readdir as readdir2, copyFile, readFile as readFile3, cp } from "fs/promises";
+import { join as join3, resolve as resolve2 } from "path";
 import chalk3 from "chalk";
 import inquirer from "inquirer";
 
-// src/core/hub-config.ts
-import { readFile } from "fs/promises";
-import { join } from "path";
-import { parse } from "yaml";
-async function loadHubConfig(dir) {
-  const configPath = join(dir, "hub.yaml");
-  const content = await readFile(configPath, "utf-8");
-  return parse(content);
-}
-
 // src/core/hub-cache.ts
 import { createHash } from "crypto";
 import { existsSync } from "fs";
-import { mkdir, readdir, readFile as readFile2, writeFile } from "fs/promises";
-import { join as join2 } from "path";
+import { mkdir, readdir, readFile, writeFile } from "fs/promises";
+import { join } from "path";
 import chalk from "chalk";
 var HUB_DIR = ".hub";
 var CONFIG_FILE = "config.json";
 async function readCache(hubDir) {
-  const filePath = join2(hubDir, HUB_DIR, CONFIG_FILE);
+  const filePath = join(hubDir, HUB_DIR, CONFIG_FILE);
   if (!existsSync(filePath)) return {};
   try {
-    const content = await readFile2(filePath, "utf-8");
+    const content = await readFile(filePath, "utf-8");
     return JSON.parse(content);
   } catch {
     return {};
   }
 }
 async function writeCache(hubDir, cache) {
-  const dir = join2(hubDir, HUB_DIR);
+  const dir = join(hubDir, HUB_DIR);
   await mkdir(dir, { recursive: true });
-  await writeFile(join2(dir, CONFIG_FILE), JSON.stringify(cache, null, 2) + "\n", "utf-8");
+  await writeFile(join(dir, CONFIG_FILE), JSON.stringify(cache, null, 2) + "\n", "utf-8");
 }
 async function getSavedEditor(hubDir) {
   const cache = await readCache(hubDir);
@@ -57,9 +51,9 @@ async function collectFileHashes(dir, extensions) {
   const entries = await readdir(dir, { withFileTypes: true });
   const hashes = [];
   for (const entry of entries) {
-    const fullPath = join2(dir, entry.name);
+    const fullPath = join(dir, entry.name);
     if (entry.isFile() && extensions.some((ext) => entry.name.endsWith(ext))) {
-      const content = await readFile2(fullPath, "utf-8");
+      const content = await readFile(fullPath, "utf-8");
       hashes.push(`${entry.name}:${createHash("sha256").update(content).digest("hex")}`);
     } else if (entry.isDirectory()) {
       const subHashes = await collectFileHashes(fullPath, extensions);
@@ -70,14 +64,16 @@ async function collectFileHashes(dir, extensions) {
 }
 async function computeInputsHash(hubDir) {
   const parts = [];
-  const hubYamlPath = join2(hubDir, "hub.yaml");
-  if (existsSync(hubYamlPath)) {
-    const content = await readFile2(hubYamlPath, "utf-8");
-    parts.push(`hub.yaml:${createHash("sha256").update(content).digest("hex")}`);
+  const { resolveConfigPath } = await import("./hub-config-UATYEV6Q.js");
+  const { path: activeConfigPath, format } = resolveConfigPath(hubDir);
+  if (existsSync(activeConfigPath)) {
+    const configFile = format === "typescript" ? "hub.config.ts" : "hub.yaml";
+    const content = await readFile(activeConfigPath, "utf-8");
+    parts.push(`${configFile}:${createHash("sha256").update(content).digest("hex")}`);
   }
   const dirs = ["agents", "skills", "hooks", "commands"];
   for (const dir of dirs) {
-    const dirHashes = await collectFileHashes(join2(hubDir, dir), [".md", ".sh"]);
+    const dirHashes = await collectFileHashes(join(hubDir, dir), [".md", ".sh"]);
     parts.push(...dirHashes.map((h) => `${dir}/${h}`));
   }
   return createHash("sha256").update(parts.join("\n")).digest("hex");
@@ -121,7 +117,7 @@ async function checkAndAutoRegenerate(hubDir) {
       return;
     }
     console.log(chalk.yellow("\n  Detected outdated configs, auto-regenerating..."));
-    const { generators: generators2 } = await import("./generate-H4YM3WTV.js");
+    const { generators: generators2 } = await import("./generate-KSB3QH7S.js");
     const generator = generators2[result.editor];
     if (!generator) {
       console.log(chalk.red(`  Unknown editor '${result.editor}' in cache. Run 'hub generate' manually.`));
@@ -138,8 +134,8 @@ async function checkAndAutoRegenerate(hubDir) {
 }
 
 // src/core/design-sources.ts
-import { mkdir as mkdir2, readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
-import { join as join3, relative, resolve } from "path";
+import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { join as join2, relative, resolve } from "path";
 import chalk2 from "chalk";
 
 // src/core/notion.ts
@@ -325,7 +321,7 @@ async function fetchFromPath(source, hubDir) {
   if (rel.startsWith("..") || resolve(fullPath) === fullPath && !fullPath.startsWith(hubDir)) {
     throw new Error(`Path "${source.path}" escapes the workspace for source: ${source.name}`);
   }
-  return readFile3(fullPath, "utf-8");
+  return readFile2(fullPath, "utf-8");
 }
 async function fetchSourceContent(source, hubDir) {
   if (source.notion_page) return fetchFromNotion(source);
@@ -372,16 +368,16 @@ async function fetchRemoteSources(sources, hubDir, skillsDir, steeringDir) {
         instructions: source.instructions
       };
       if (source.type === "skill") {
-        const skillDir = join3(skillsDir, source.name);
+        const skillDir = join2(skillsDir, source.name);
         await mkdir2(skillDir, { recursive: true });
         const skillContent = buildSkillContent(fetched);
-        await writeFile2(join3(skillDir, "SKILL.md"), skillContent, "utf-8");
+        await writeFile2(join2(skillDir, "SKILL.md"), skillContent, "utf-8");
         skillCount++;
         console.log(chalk2.green(`  \u2713 ${source.name} (skill)`));
       } else {
         await mkdir2(steeringDir, { recursive: true });
         const steeringContent = buildSteeringContent(fetched);
-        await writeFile2(join3(steeringDir, `${source.name}.md`), steeringContent, "utf-8");
+        await writeFile2(join2(steeringDir, `${source.name}.md`), steeringContent, "utf-8");
         steeringCount++;
         console.log(chalk2.green(`  \u2713 ${source.name} (steering)`));
       }
@@ -470,7 +466,7 @@ async function readExistingMcpDisabledState(mcpJsonPath) {
   const disabledState = {};
   if (!existsSync2(mcpJsonPath)) return disabledState;
   try {
-    const content = JSON.parse(await readFile4(mcpJsonPath, "utf-8"));
+    const content = JSON.parse(await readFile3(mcpJsonPath, "utf-8"));
     const servers = content.mcpServers || content.mcp || {};
     for (const [name, config] of Object.entries(servers)) {
       if (typeof config.disabled === "boolean") {
@@ -496,7 +492,7 @@ async function fetchHubDocsSkill(skillsDir) {
       return;
     }
     const content = await res.text();
-    const hubSkillDir = join4(skillsDir, "hub-docs");
+    const hubSkillDir = join3(skillsDir, "hub-docs");
     await mkdir3(hubSkillDir, { recursive: true });
     const skillContent = `---
 name: hub-docs
@@ -505,7 +501,7 @@ triggers: [hub, rhm, hub.yaml, generate, scan, setup, orchestrator, multi-repo,
 ---
 
 ${content}`;
-    await writeFile3(join4(hubSkillDir, "SKILL.md"), skillContent, "utf-8");
+    await writeFile3(join3(hubSkillDir, "SKILL.md"), skillContent, "utf-8");
     console.log(chalk3.green("  Fetched hub-docs skill from hub.arvore.com.br"));
   } catch {
     console.log(chalk3.yellow(`  Could not fetch hub docs, skipping hub-docs skill`));
@@ -580,7 +576,7 @@ function buildClaudeHooks(hooks) {
   return claudeHooks;
 }
 async function generateEditorCommands(config, hubDir, targetDir, editorName) {
-  const commandsDir = join4(targetDir, "commands");
+  const commandsDir = join3(targetDir, "commands");
   let count = 0;
   if (config.commands_dir) {
     const srcDir = resolve2(hubDir, config.commands_dir);
@@ -590,7 +586,7 @@ async function generateEditorCommands(config, hubDir, targetDir, editorName) {
       if (mdFiles.length > 0) {
         await mkdir3(commandsDir, { recursive: true });
         for (const file of mdFiles) {
-          await copyFile(join4(srcDir, file), join4(commandsDir, file));
+          await copyFile(join3(srcDir, file), join3(commandsDir, file));
           count++;
         }
       }
@@ -602,7 +598,7 @@ async function generateEditorCommands(config, hubDir, targetDir, editorName) {
     await mkdir3(commandsDir, { recursive: true });
     for (const [name, filePath] of Object.entries(config.commands)) {
       const src = resolve2(hubDir, filePath);
-      const dest = join4(commandsDir, name.endsWith(".md") ? name : `${name}.md`);
+      const dest = join3(commandsDir, name.endsWith(".md") ? name : `${name}.md`);
       try {
         await copyFile(src, dest);
         count++;
@@ -618,7 +614,7 @@ async function generateEditorCommands(config, hubDir, targetDir, editorName) {
 async function writeManagedFile(filePath, managedLines) {
   const managedBlock = [HUB_MARKER_START, ...managedLines, HUB_MARKER_END].join("\n");
   if (existsSync2(filePath)) {
-    const existing = await readFile4(filePath, "utf-8");
+    const existing = await readFile3(filePath, "utf-8");
     const startIdx = existing.indexOf(HUB_MARKER_START);
     const endIdx = existing.indexOf(HUB_MARKER_END);
     if (startIdx !== -1 && endIdx !== -1) {
@@ -633,11 +629,11 @@ async function writeManagedFile(filePath, managedLines) {
   await writeFile3(filePath, managedBlock + "\n", "utf-8");
 }
 async function generateCursor(config, hubDir) {
-  const cursorDir = join4(hubDir, ".cursor");
-  await mkdir3(join4(cursorDir, "rules"), { recursive: true });
-  await mkdir3(join4(cursorDir, "agents"), { recursive: true });
+  const cursorDir = join3(hubDir, ".cursor");
+  await mkdir3(join3(cursorDir, "rules"), { recursive: true });
+  await mkdir3(join3(cursorDir, "agents"), { recursive: true });
   const gitignoreLines = buildGitignoreLines(config);
-  await writeManagedFile(join4(hubDir, ".gitignore"), gitignoreLines);
+  await writeManagedFile(join3(hubDir, ".gitignore"), gitignoreLines);
   console.log(chalk3.green("  Generated .gitignore"));
   const cursorignoreLines = [
     "# Re-include repositories for AI context"
@@ -647,7 +643,7 @@ async function generateCursor(config, hubDir) {
     cursorignoreLines.push(`!${repoDir}/`);
   }
   cursorignoreLines.push("", "# Re-include tasks for agent collaboration", "!tasks/");
-  await writeManagedFile(join4(hubDir, ".cursorignore"), cursorignoreLines);
+  await writeManagedFile(join3(hubDir, ".cursorignore"), cursorignoreLines);
   console.log(chalk3.green("  Generated .cursorignore"));
   if (config.mcps?.length) {
     const mcpConfig = {};
@@ -661,21 +657,21 @@ async function generateCursor(config, hubDir) {
       }
     }
     await writeFile3(
-      join4(cursorDir, "mcp.json"),
+      join3(cursorDir, "mcp.json"),
       JSON.stringify({ mcpServers: mcpConfig }, null, 2) + "\n",
       "utf-8"
     );
     console.log(chalk3.green("  Generated .cursor/mcp.json"));
   }
   const orchestratorRule = buildOrchestratorRule(config);
-  await writeFile3(join4(cursorDir, "rules", "orchestrator.mdc"), orchestratorRule, "utf-8");
+  await writeFile3(join3(cursorDir, "rules", "orchestrator.mdc"), orchestratorRule, "utf-8");
   console.log(chalk3.green("  Generated .cursor/rules/orchestrator.mdc"));
   const hubSteeringDirCursor = resolve2(hubDir, "steering");
   try {
     const steeringFiles = await readdir2(hubSteeringDirCursor);
     const mdFiles = steeringFiles.filter((f) => f.endsWith(".md"));
     for (const file of mdFiles) {
-      const raw = await readFile4(join4(hubSteeringDirCursor, file), "utf-8");
+      const raw = await readFile3(join3(hubSteeringDirCursor, file), "utf-8");
       const content = stripFrontMatter(raw);
       const mdcName = file.replace(/\.md$/, ".mdc");
       const mdcContent = `---
@@ -684,7 +680,7 @@ alwaysApply: true
 ---
 
 ${content}`;
-      await writeFile3(join4(cursorDir, "rules", mdcName), mdcContent, "utf-8");
+      await writeFile3(join3(cursorDir, "rules", mdcName), mdcContent, "utf-8");
     }
     if (mdFiles.length > 0) {
       console.log(chalk3.green(`  Copied ${mdFiles.length} steering files to .cursor/rules/`));
@@ -696,7 +692,7 @@ ${content}`;
     const agentFiles = await readdir2(agentsDir);
     const mdFiles = agentFiles.filter((f) => f.endsWith(".md"));
     for (const file of mdFiles) {
-      await copyFile(join4(agentsDir, file), join4(cursorDir, "agents", file));
+      await copyFile(join3(agentsDir, file), join3(cursorDir, "agents", file));
     }
     console.log(chalk3.green(`  Copied ${mdFiles.length} agent definitions`));
   } catch {
@@ -705,15 +701,15 @@ ${content}`;
   const skillsDir = resolve2(hubDir, "skills");
   try {
     const skillFolders = await readdir2(skillsDir);
-    const cursorSkillsDir = join4(cursorDir, "skills");
+    const cursorSkillsDir = join3(cursorDir, "skills");
     await mkdir3(cursorSkillsDir, { recursive: true });
     let count = 0;
     for (const folder of skillFolders) {
-      const skillFile = join4(skillsDir, folder, "SKILL.md");
+      const skillFile = join3(skillsDir, folder, "SKILL.md");
       try {
-        await readFile4(skillFile);
-        const srcDir = join4(skillsDir, folder);
-        const targetDir = join4(cursorSkillsDir, folder);
+        await readFile3(skillFile);
+        const srcDir = join3(skillsDir, folder);
+        const targetDir = join3(cursorSkillsDir, folder);
         await cp(srcDir, targetDir, { recursive: true });
         count++;
       } catch {
@@ -724,15 +720,15 @@ ${content}`;
     }
   } catch {
   }
-  const cursorSkillsDirForDocs = join4(cursorDir, "skills");
+  const cursorSkillsDirForDocs = join3(cursorDir, "skills");
   await mkdir3(cursorSkillsDirForDocs, { recursive: true });
   await fetchHubDocsSkill(cursorSkillsDirForDocs);
-  await syncRemoteSources(config, hubDir, join4(cursorDir, "skills"), join4(cursorDir, "rules"));
+  await syncRemoteSources(config, hubDir, join3(cursorDir, "skills"), join3(cursorDir, "rules"));
   if (config.hooks) {
     const cursorHooks = buildCursorHooks(config.hooks);
     if (cursorHooks) {
       await writeFile3(
-        join4(cursorDir, "hooks.json"),
+        join3(cursorDir, "hooks.json"),
         JSON.stringify(cursorHooks, null, 2) + "\n",
         "utf-8"
       );
@@ -977,6 +973,7 @@ function buildMcpToolsSection(mcps) {
   const proxyMcp = mcps.find((m) => m.upstreams && m.upstreams.length > 0);
   const upstreamNames = getUpstreamNames(mcps);
   const directMcps = mcps.filter((m) => !m.upstreams && !upstreamNames.has(m.name));
+  const mcpByName = new Map(mcps.map((m) => [m.name, m]));
   if (!proxyMcp && directMcps.length === 0) return "";
   const lines = [];
   lines.push(`
@@ -993,20 +990,33 @@ Some MCPs are aggregated behind a proxy (\`${proxyMcp.name}\`). Their tools are
 
 **MCPs available via proxy:**`);
     for (const name of proxyMcp.upstreams) {
-      lines.push(`- \`${name}\``);
+      const mcp = mcpByName.get(name);
+      const desc = mcp?.description ? ` \u2014 ${mcp.description}` : "";
+      lines.push(`- \`${name}\`${desc}`);
     }
   }
   if (directMcps.length > 0) {
     lines.push(`
 **MCPs available directly:**`);
     for (const mcp of directMcps) {
-      lines.push(`- \`${mcp.name}\``);
+      const desc = mcp.description ? ` \u2014 ${mcp.description}` : "";
+      lines.push(`- \`${mcp.name}\`${desc}`);
     }
   }
   if (proxyMcp) {
     lines.push(`
 > When you need a capability and are unsure which tool to use, always try \`mcp_search\` first with relevant keywords. The proxy aggregates tools from all upstream MCPs.`);
   }
+  const mcpsWithInstructions = mcps.filter((m) => m.instructions && !m.upstreams);
+  if (mcpsWithInstructions.length > 0) {
+    lines.push(`
+### MCP Instructions`);
+    for (const mcp of mcpsWithInstructions) {
+      lines.push(`
+#### ${mcp.name}
+${mcp.instructions.trim()}`);
+    }
+  }
   return lines.join("\n");
 }
 function buildOpenCodeOrchestratorRule(config) {
@@ -1198,26 +1208,26 @@ If any validation agent leaves comments requiring fixes, call the relevant codin
   return parts.join("\n");
 }
 async function generateOpenCode(config, hubDir) {
-  const opencodeDir = join4(hubDir, ".opencode");
-  await mkdir3(join4(opencodeDir, "agents"), { recursive: true });
-  await mkdir3(join4(opencodeDir, "rules"), { recursive: true });
-  await mkdir3(join4(opencodeDir, "skills"), { recursive: true });
-  await mkdir3(join4(opencodeDir, "commands"), { recursive: true });
-  await mkdir3(join4(opencodeDir, "plugins"), { recursive: true });
+  const opencodeDir = join3(hubDir, ".opencode");
+  await mkdir3(join3(opencodeDir, "agents"), { recursive: true });
+  await mkdir3(join3(opencodeDir, "rules"), { recursive: true });
+  await mkdir3(join3(opencodeDir, "skills"), { recursive: true });
+  await mkdir3(join3(opencodeDir, "commands"), { recursive: true });
+  await mkdir3(join3(opencodeDir, "plugins"), { recursive: true });
   const gitignoreLines = buildGitignoreLines(config);
-  await writeManagedFile(join4(hubDir, ".gitignore"), gitignoreLines);
+  await writeManagedFile(join3(hubDir, ".gitignore"), gitignoreLines);
   console.log(chalk3.green("  Generated .gitignore"));
   const orchestratorRule = buildOpenCodeOrchestratorRule(config);
-  await writeFile3(join4(opencodeDir, "rules", "orchestrator.md"), orchestratorRule + "\n", "utf-8");
+  await writeFile3(join3(opencodeDir, "rules", "orchestrator.md"), orchestratorRule + "\n", "utf-8");
   console.log(chalk3.green("  Generated .opencode/rules/orchestrator.md"));
   const hubSteeringDirOC = resolve2(hubDir, "steering");
   try {
     const steeringFiles = await readdir2(hubSteeringDirOC);
     const mdFiles = steeringFiles.filter((f) => f.endsWith(".md"));
     for (const file of mdFiles) {
-      const raw = await readFile4(join4(hubSteeringDirOC, file), "utf-8");
+      const raw = await readFile3(join3(hubSteeringDirOC, file), "utf-8");
       const content = stripFrontMatter(raw);
-      await writeFile3(join4(opencodeDir, "rules", file), content, "utf-8");
+      await writeFile3(join3(opencodeDir, "rules", file), content, "utf-8");
     }
     if (mdFiles.length > 0) {
       console.log(chalk3.green(`  Copied ${mdFiles.length} steering files to .opencode/rules/`));
@@ -1242,7 +1252,7 @@ async function generateOpenCode(config, hubDir) {
   }
   opencodeConfig.instructions = [".opencode/rules/*.md"];
   await writeFile3(
-    join4(hubDir, "opencode.json"),
+    join3(hubDir, "opencode.json"),
     JSON.stringify(opencodeConfig, null, 2) + "\n",
     "utf-8"
   );
@@ -1252,10 +1262,10 @@ async function generateOpenCode(config, hubDir) {
     const agentFiles = await readdir2(agentsDir);
     const mdFiles = agentFiles.filter((f) => f.endsWith(".md"));
     for (const file of mdFiles) {
-      const content = await readFile4(join4(agentsDir, file), "utf-8");
+      const content = await readFile3(join3(agentsDir, file), "utf-8");
       const agentName = file.replace(/\.md$/, "");
       const converted = buildOpenCodeAgentMarkdown(agentName, content);
-      await writeFile3(join4(opencodeDir, "agents", file), converted, "utf-8");
+      await writeFile3(join3(opencodeDir, "agents", file), converted, "utf-8");
     }
     console.log(chalk3.green(`  Copied ${mdFiles.length} agents to .opencode/agents/`));
   } catch {
@@ -1266,10 +1276,10 @@ async function generateOpenCode(config, hubDir) {
     const skillFolders = await readdir2(skillsDir);
     let count = 0;
     for (const folder of skillFolders) {
-      const skillFile = join4(skillsDir, folder, "SKILL.md");
+      const skillFile = join3(skillsDir, folder, "SKILL.md");
       try {
-        await readFile4(skillFile);
-        await cp(join4(skillsDir, folder), join4(opencodeDir, "skills", folder), { recursive: true });
+        await readFile3(skillFile);
+        await cp(join3(skillsDir, folder), join3(opencodeDir, "skills", folder), { recursive: true });
         count++;
       } catch {
       }
@@ -1279,13 +1289,13 @@ async function generateOpenCode(config, hubDir) {
     }
   } catch {
   }
-  await fetchHubDocsSkill(join4(opencodeDir, "skills"));
-  await syncRemoteSources(config, hubDir, join4(opencodeDir, "skills"), join4(opencodeDir, "rules"));
+  await fetchHubDocsSkill(join3(opencodeDir, "skills"));
+  await syncRemoteSources(config, hubDir, join3(opencodeDir, "skills"), join3(opencodeDir, "rules"));
   await generateEditorCommands(config, hubDir, opencodeDir, ".opencode/commands/");
   if (config.hooks) {
     const plugin = buildOpenCodeHooksPlugin(config.hooks);
     if (plugin) {
-      await writeFile3(join4(opencodeDir, "plugins", "hub-hooks.js"), plugin, "utf-8");
+      await writeFile3(join3(opencodeDir, "plugins", "hub-hooks.js"), plugin, "utf-8");
       console.log(chalk3.green("  Generated .opencode/plugins/hub-hooks.js"));
     }
   }
@@ -1758,8 +1768,8 @@ function formatAction(action) {
   return map[action] || action;
 }
 async function generateClaudeCode(config, hubDir) {
-  const claudeDir = join4(hubDir, ".claude");
-  await mkdir3(join4(claudeDir, "agents"), { recursive: true });
+  const claudeDir = join3(hubDir, ".claude");
+  await mkdir3(join3(claudeDir, "agents"), { recursive: true });
   const orchestratorRule = buildOrchestratorRule(config);
   const cleanedOrchestrator = orchestratorRule.replace(/^---[\s\S]*?---\n/m, "").trim();
   const claudeMdSections = [];
@@ -1769,7 +1779,7 @@ async function generateClaudeCode(config, hubDir) {
     const agentFiles = await readdir2(agentsDir);
     const mdFiles = agentFiles.filter((f) => f.endsWith(".md"));
     for (const file of mdFiles) {
-      await copyFile(join4(agentsDir, file), join4(claudeDir, "agents", file));
+      await copyFile(join3(agentsDir, file), join3(claudeDir, "agents", file));
     }
     console.log(chalk3.green(`  Copied ${mdFiles.length} agents to .claude/agents/`));
   } catch {
@@ -1778,15 +1788,15 @@ async function generateClaudeCode(config, hubDir) {
   const skillsDir = resolve2(hubDir, "skills");
   try {
     const skillFolders = await readdir2(skillsDir);
-    const claudeSkillsDir = join4(claudeDir, "skills");
+    const claudeSkillsDir = join3(claudeDir, "skills");
     await mkdir3(claudeSkillsDir, { recursive: true });
     let count = 0;
     for (const folder of skillFolders) {
-      const skillFile = join4(skillsDir, folder, "SKILL.md");
+      const skillFile = join3(skillsDir, folder, "SKILL.md");
       try {
-        await readFile4(skillFile);
-        const srcDir = join4(skillsDir, folder);
-        const targetDir = join4(claudeSkillsDir, folder);
+        await readFile3(skillFile);
+        const srcDir = join3(skillsDir, folder);
+        const targetDir = join3(claudeSkillsDir, folder);
         await cp(srcDir, targetDir, { recursive: true });
         count++;
       } catch {
@@ -1797,16 +1807,16 @@ async function generateClaudeCode(config, hubDir) {
     }
   } catch {
   }
-  const claudeSkillsDirForDocs = join4(claudeDir, "skills");
+  const claudeSkillsDirForDocs = join3(claudeDir, "skills");
   await mkdir3(claudeSkillsDirForDocs, { recursive: true });
   await fetchHubDocsSkill(claudeSkillsDirForDocs);
-  await syncRemoteSources(config, hubDir, join4(claudeDir, "skills"), join4(claudeDir, "steering"));
+  await syncRemoteSources(config, hubDir, join3(claudeDir, "skills"), join3(claudeDir, "steering"));
   const hubSteeringDirClaude = resolve2(hubDir, "steering");
   try {
     const steeringFiles = await readdir2(hubSteeringDirClaude);
     const mdFiles = steeringFiles.filter((f) => f.endsWith(".md"));
     for (const file of mdFiles) {
-      const raw = await readFile4(join4(hubSteeringDirClaude, file), "utf-8");
+      const raw = await readFile3(join3(hubSteeringDirClaude, file), "utf-8");
       const content = stripFrontMatter(raw).trim();
       if (content) {
         claudeMdSections.push(content);
@@ -1817,7 +1827,7 @@ async function generateClaudeCode(config, hubDir) {
     }
   } catch {
   }
-  await writeFile3(join4(hubDir, "CLAUDE.md"), claudeMdSections.join("\n\n"), "utf-8");
+  await writeFile3(join3(hubDir, "CLAUDE.md"), claudeMdSections.join("\n\n"), "utf-8");
   console.log(chalk3.green("  Generated CLAUDE.md"));
   if (config.mcps?.length) {
     const mcpJson = {};
@@ -1831,7 +1841,7 @@ async function generateClaudeCode(config, hubDir) {
       }
     }
     await writeFile3(
-      join4(hubDir, ".mcp.json"),
+      join3(hubDir, ".mcp.json"),
       JSON.stringify({ mcpServers: mcpJson }, null, 2) + "\n",
       "utf-8"
     );
@@ -1874,19 +1884,19 @@ async function generateClaudeCode(config, hubDir) {
     }
   }
   await writeFile3(
-    join4(claudeDir, "settings.json"),
+    join3(claudeDir, "settings.json"),
     JSON.stringify(claudeSettings, null, 2) + "\n",
     "utf-8"
   );
   console.log(chalk3.green("  Generated .claude/settings.json"));
   const gitignoreLines = buildGitignoreLines(config);
-  await writeManagedFile(join4(hubDir, ".gitignore"), gitignoreLines);
+  await writeManagedFile(join3(hubDir, ".gitignore"), gitignoreLines);
   console.log(chalk3.green("  Generated .gitignore"));
 }
 async function generateKiro(config, hubDir) {
-  const kiroDir = join4(hubDir, ".kiro");
-  const steeringDir = join4(kiroDir, "steering");
-  const settingsDir = join4(kiroDir, "settings");
+  const kiroDir = join3(hubDir, ".kiro");
+  const steeringDir = join3(kiroDir, "steering");
+  const settingsDir = join3(kiroDir, "settings");
   await mkdir3(steeringDir, { recursive: true });
   await mkdir3(settingsDir, { recursive: true });
   let mode = await getKiroMode(hubDir);
@@ -1909,26 +1919,26 @@ async function generateKiro(config, hubDir) {
     console.log(chalk3.dim(`  Using saved Kiro mode: ${mode}`));
   }
   const gitignoreLines = buildGitignoreLines(config);
-  await writeManagedFile(join4(hubDir, ".gitignore"), gitignoreLines);
+  await writeManagedFile(join3(hubDir, ".gitignore"), gitignoreLines);
   console.log(chalk3.green("  Generated .gitignore"));
   const kiroRule = buildKiroOrchestratorRule(config);
   const kiroOrchestrator = buildKiroSteeringContent(kiroRule, "always", { name: "orchestrator" });
-  await writeFile3(join4(steeringDir, "orchestrator.md"), kiroOrchestrator, "utf-8");
+  await writeFile3(join3(steeringDir, "orchestrator.md"), kiroOrchestrator, "utf-8");
   console.log(chalk3.green("  Generated .kiro/steering/orchestrator.md"));
-  await writeFile3(join4(hubDir, "AGENTS.md"), kiroRule + "\n", "utf-8");
+  await writeFile3(join3(hubDir, "AGENTS.md"), kiroRule + "\n", "utf-8");
   console.log(chalk3.green("  Generated AGENTS.md"));
   const hubSteeringDir = resolve2(hubDir, "steering");
   try {
     const steeringFiles = await readdir2(hubSteeringDir);
     const mdFiles = steeringFiles.filter((f) => f.endsWith(".md"));
     for (const file of mdFiles) {
-      const raw = await readFile4(join4(hubSteeringDir, file), "utf-8");
+      const raw = await readFile3(join3(hubSteeringDir, file), "utf-8");
       const content = stripFrontMatter(raw);
-      const destPath = join4(steeringDir, file);
+      const destPath = join3(steeringDir, file);
       let inclusion = "always";
       let meta;
       if (existsSync2(destPath)) {
-        const existingContent = await readFile4(destPath, "utf-8");
+        const existingContent = await readFile3(destPath, "utf-8");
         const existingFm = parseFrontMatter(existingContent);
         if (existingFm) {
           if (existingFm.inclusion === "auto" || existingFm.inclusion === "manual" || existingFm.inclusion === "fileMatch") {
@@ -1962,14 +1972,14 @@ async function generateKiro(config, hubDir) {
   }
   const agentsDir = resolve2(hubDir, "agents");
   try {
-    const kiroAgentsDir = join4(kiroDir, "agents");
+    const kiroAgentsDir = join3(kiroDir, "agents");
     await mkdir3(kiroAgentsDir, { recursive: true });
     const agentFiles = await readdir2(agentsDir);
     const mdFiles = agentFiles.filter((f) => f.endsWith(".md"));
     for (const file of mdFiles) {
-      const agentContent = await readFile4(join4(agentsDir, file), "utf-8");
+      const agentContent = await readFile3(join3(agentsDir, file), "utf-8");
       const kiroAgent = buildKiroAgentContent(agentContent);
-      await writeFile3(join4(kiroAgentsDir, file), kiroAgent, "utf-8");
+      await writeFile3(join3(kiroAgentsDir, file), kiroAgent, "utf-8");
     }
     console.log(chalk3.green(`  Copied ${mdFiles.length} agents to .kiro/agents/`));
   } catch {
@@ -1978,15 +1988,15 @@ async function generateKiro(config, hubDir) {
   const skillsDir = resolve2(hubDir, "skills");
   try {
     const skillFolders = await readdir2(skillsDir);
-    const kiroSkillsDir = join4(kiroDir, "skills");
+    const kiroSkillsDir = join3(kiroDir, "skills");
     await mkdir3(kiroSkillsDir, { recursive: true });
     let count = 0;
     for (const folder of skillFolders) {
-      const skillFile = join4(skillsDir, folder, "SKILL.md");
+      const skillFile = join3(skillsDir, folder, "SKILL.md");
       try {
-        await readFile4(skillFile);
-        const srcDir = join4(skillsDir, folder);
-        const targetDir = join4(kiroSkillsDir, folder);
+        await readFile3(skillFile);
+        const srcDir = join3(skillsDir, folder);
+        const targetDir = join3(kiroSkillsDir, folder);
         await cp(srcDir, targetDir, { recursive: true });
         count++;
       } catch {
@@ -1997,10 +2007,10 @@ async function generateKiro(config, hubDir) {
     }
   } catch {
   }
-  const kiroSkillsDirForDocs = join4(kiroDir, "skills");
+  const kiroSkillsDirForDocs = join3(kiroDir, "skills");
   await mkdir3(kiroSkillsDirForDocs, { recursive: true });
   await fetchHubDocsSkill(kiroSkillsDirForDocs);
-  await syncRemoteSources(config, hubDir, join4(kiroDir, "skills"), steeringDir);
+  await syncRemoteSources(config, hubDir, join3(kiroDir, "skills"), steeringDir);
   if (config.mcps?.length) {
     const mcpConfig = {};
     const upstreamSet = getUpstreamNames(config.mcps);
@@ -2013,7 +2023,7 @@ async function generateKiro(config, hubDir) {
         mcpConfig[mcp.name] = buildKiroMcpEntry(mcp, mode);
       }
     }
-    const mcpJsonPath = join4(settingsDir, "mcp.json");
+    const mcpJsonPath = join3(settingsDir, "mcp.json");
     const disabledState = await readExistingMcpDisabledState(mcpJsonPath);
     applyDisabledState(mcpConfig, disabledState);
     await writeFile3(
@@ -2043,13 +2053,13 @@ async function generateKiro(config, hubDir) {
   await generateVSCodeSettings(config, hubDir);
 }
 async function generateVSCodeSettings(config, hubDir) {
-  const vscodeDir = join4(hubDir, ".vscode");
+  const vscodeDir = join3(hubDir, ".vscode");
   await mkdir3(vscodeDir, { recursive: true });
-  const settingsPath = join4(vscodeDir, "settings.json");
+  const settingsPath = join3(vscodeDir, "settings.json");
   let existing = {};
   if (existsSync2(settingsPath)) {
     try {
-      const raw = await readFile4(settingsPath, "utf-8");
+      const raw = await readFile3(settingsPath, "utf-8");
       existing = JSON.parse(raw);
     } catch {
       existing = {};
@@ -2064,11 +2074,11 @@ async function generateVSCodeSettings(config, hubDir) {
   await writeFile3(settingsPath, JSON.stringify(merged, null, 2) + "\n", "utf-8");
   console.log(chalk3.green("  Generated .vscode/settings.json (git multi-repo detection)"));
   const workspaceFile = `${config.name}.code-workspace`;
-  const workspacePath = join4(hubDir, workspaceFile);
+  const workspacePath = join3(hubDir, workspaceFile);
   let existingWorkspace = {};
   if (existsSync2(workspacePath)) {
     try {
-      const raw = await readFile4(workspacePath, "utf-8");
+      const raw = await readFile3(workspacePath, "utf-8");
       existingWorkspace = JSON.parse(raw);
     } catch {
       existingWorkspace = {};
@@ -2078,7 +2088,7 @@ async function generateVSCodeSettings(config, hubDir) {
     const existing2 = files.find((f) => f.endsWith(".code-workspace"));
     if (existing2) {
       try {
-        const raw = await readFile4(join4(hubDir, existing2), "utf-8");
+        const raw = await readFile3(join3(hubDir, existing2), "utf-8");
         existingWorkspace = JSON.parse(raw);
       } catch {
         existingWorkspace = {};
@@ -2161,7 +2171,7 @@ async function generateEnvExample(config, hubDir) {
     totalVars++;
   }
   if (totalVars === 0) return;
-  await writeFile3(join4(hubDir, ".env.example"), lines.join("\n") + "\n", "utf-8");
+  await writeFile3(join3(hubDir, ".env.example"), lines.join("\n") + "\n", "utf-8");
   console.log(chalk3.green(`  Generated .env.example (${totalVars} vars)`));
 }
 function buildGitignoreLines(config) {
@@ -2309,7 +2319,6 @@ Generating ${generator.name} configuration
 });
 
 export {
-  loadHubConfig,
   generators,
   generateCommand,
   checkAndAutoRegenerate