@arvoretech/hub 0.8.2 → 0.10.0

package/dist/{chunk-T2UKYK2B.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 mkdir2, writeFile as writeFile2, readdir as readdir2, copyFile, readFile as readFile3, cp } from "fs/promises";
-import { join as join3, resolve } from "path";
-import chalk2 from "chalk";
+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-7YPRUSN5.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.`));
@@ -137,8 +133,317 @@ async function checkAndAutoRegenerate(hubDir) {
   }
 }
 
+// src/core/design-sources.ts
+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
+var NOTION_API_VERSION = "2022-06-28";
+function getNotionToken() {
+  return process.env.NOTION_API_KEY || process.env.NOTION_TOKEN;
+}
+function extractPageId(pageRef) {
+  const cleaned = pageRef.replace(/https?:\/\/(?:www\.)?notion\.(?:so|site)\//, "");
+  const withoutSlug = cleaned.split("?")[0].split("#")[0];
+  const segments = withoutSlug.split("/");
+  const last = segments[segments.length - 1] || "";
+  const dashParts = last.split("-");
+  const candidate = dashParts[dashParts.length - 1];
+  if (candidate && /^[a-f0-9]{32}$/i.test(candidate)) {
+    return formatPageId(candidate);
+  }
+  const noDashes = pageRef.replace(/-/g, "");
+  const hexMatch = noDashes.match(/([a-f0-9]{32})/i);
+  if (hexMatch) return formatPageId(hexMatch[1]);
+  return pageRef;
+}
+function formatPageId(raw) {
+  return `${raw.slice(0, 8)}-${raw.slice(8, 12)}-${raw.slice(12, 16)}-${raw.slice(16, 20)}-${raw.slice(20)}`;
+}
+function richTextToMarkdown(richTexts) {
+  return richTexts.map((rt) => {
+    let text = rt.plain_text;
+    if (!text) return "";
+    if (rt.annotations?.code) text = `\`${text}\``;
+    if (rt.annotations?.bold) text = `**${text}**`;
+    if (rt.annotations?.italic) text = `*${text}*`;
+    if (rt.annotations?.strikethrough) text = `~~${text}~~`;
+    if (rt.href) text = `[${text}](${rt.href})`;
+    return text;
+  }).join("");
+}
+async function notionFetch(endpoint, token) {
+  const res = await fetch(`https://api.notion.com/v1${endpoint}`, {
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "Notion-Version": NOTION_API_VERSION
+    }
+  });
+  if (!res.ok) {
+    throw new Error(`Notion API ${res.status}: ${res.statusText}`);
+  }
+  return res.json();
+}
+async function fetchAllBlocks(pageId, token) {
+  const blocks = [];
+  let cursor;
+  do {
+    const qs = cursor ? `?start_cursor=${cursor}` : "";
+    const data = await notionFetch(`/blocks/${pageId}/children${qs}`, token);
+    blocks.push(...data.results);
+    cursor = data.has_more ? data.next_cursor ?? void 0 : void 0;
+  } while (cursor);
+  return blocks;
+}
+function blockToMarkdown(block, indent = "") {
+  const type = block.type;
+  const data = block[type];
+  if (!data) return "";
+  const rt = data.rich_text || [];
+  const text = richTextToMarkdown(rt);
+  switch (type) {
+    case "paragraph":
+      return text ? `${indent}${text}` : "";
+    case "heading_1":
+      return `# ${text}`;
+    case "heading_2":
+      return `## ${text}`;
+    case "heading_3":
+      return `### ${text}`;
+    case "bulleted_list_item":
+      return `${indent}- ${text}`;
+    case "numbered_list_item":
+      return `${indent}1. ${text}`;
+    case "to_do": {
+      const checked = data.checked ? "x" : " ";
+      return `${indent}- [${checked}] ${text}`;
+    }
+    case "toggle":
+      return `${indent}<details><summary>${text}</summary>`;
+    case "code": {
+      const lang = data.language || "";
+      return `\`\`\`${lang}
+${text}
+\`\`\``;
+    }
+    case "quote":
+      return `> ${text}`;
+    case "callout":
+      return `> ${text}`;
+    case "divider":
+      return "---";
+    case "table_row": {
+      const cells = data.cells || [];
+      return `| ${cells.map((c) => richTextToMarkdown(c)).join(" | ")} |`;
+    }
+    case "image": {
+      const imgData = data;
+      const url = imgData.file?.url || imgData.external?.url || "";
+      const caption = data.caption || [];
+      const alt = richTextToMarkdown(caption) || "image";
+      return url ? `![${alt}](${url})` : "";
+    }
+    case "bookmark": {
+      const bUrl = data.url;
+      return bUrl ? `[${bUrl}](${bUrl})` : "";
+    }
+    default:
+      return text || "";
+  }
+}
+async function blocksToMarkdown(blocks, token, indent = "") {
+  const lines = [];
+  for (const block of blocks) {
+    const type = block.type;
+    if (type === "table") {
+      if (block.has_children) {
+        const children = await fetchAllBlocks(block.id, token);
+        const rows = children.map((child) => blockToMarkdown(child, indent));
+        if (rows.length > 0) {
+          lines.push(rows[0]);
+          const colCount = (rows[0].match(/\|/g)?.length || 2) - 1;
+          lines.push(`|${" --- |".repeat(colCount)}`);
+          lines.push(...rows.slice(1));
+        }
+      }
+      lines.push("");
+      continue;
+    }
+    const line = blockToMarkdown(block, indent);
+    if (line !== void 0) lines.push(line);
+    if (block.has_children && type !== "table") {
+      const children = await fetchAllBlocks(block.id, token);
+      const childMd = await blocksToMarkdown(children, token, indent + "  ");
+      if (childMd) lines.push(childMd);
+      if (type === "toggle") lines.push("</details>");
+    } else if (type === "toggle") {
+      lines.push("</details>");
+    }
+  }
+  return lines.join("\n");
+}
+async function fetchNotionPageAsMarkdown(pageRef) {
+  const token = getNotionToken();
+  if (!token) {
+    throw new Error("NOTION_API_KEY or NOTION_TOKEN env var is required to fetch Notion pages");
+  }
+  const pageId = extractPageId(pageRef);
+  const page = await notionFetch(`/pages/${pageId}`, token);
+  let title = "";
+  for (const prop of Object.values(page.properties)) {
+    if (prop.title?.length) {
+      title = prop.title.map((t) => t.plain_text).join("");
+      break;
+    }
+  }
+  const blocks = await fetchAllBlocks(pageId, token);
+  const content = await blocksToMarkdown(blocks, token);
+  return { title: title || "Untitled", content };
+}
+
+// src/core/design-sources.ts
+async function fetchFromNotion(source) {
+  if (!source.notion_page) throw new Error(`No notion_page for source: ${source.name}`);
+  const { content } = await fetchNotionPageAsMarkdown(source.notion_page);
+  return content;
+}
+async function fetchFromUrl(source) {
+  if (!source.url) throw new Error(`No url for source: ${source.name}`);
+  const res = await fetch(source.url, { signal: AbortSignal.timeout(3e4) });
+  if (!res.ok) throw new Error(`Failed to fetch ${source.url}: ${res.status}`);
+  return res.text();
+}
+async function fetchFromPath(source, hubDir) {
+  if (!source.path) throw new Error(`No path for source: ${source.name}`);
+  const fullPath = resolve(hubDir, source.path);
+  const rel = relative(hubDir, fullPath);
+  if (rel.startsWith("..") || resolve(fullPath) === fullPath && !fullPath.startsWith(hubDir)) {
+    throw new Error(`Path "${source.path}" escapes the workspace for source: ${source.name}`);
+  }
+  return readFile2(fullPath, "utf-8");
+}
+async function fetchSourceContent(source, hubDir) {
+  if (source.notion_page) return fetchFromNotion(source);
+  if (source.url) return fetchFromUrl(source);
+  if (source.path) return fetchFromPath(source, hubDir);
+  throw new Error(`Source "${source.name}" has no notion_page, url, or path`);
+}
+function buildSkillContent(source) {
+  const triggers = source.triggers?.length ? source.triggers : [source.name.replace(/-/g, " ")];
+  const parts = [
+    "---",
+    `name: ${source.name}`,
+    `description: ${source.instructions || `Design source: ${source.name}`}`,
+    `triggers: [${triggers.join(", ")}]`,
+    "---",
+    ""
+  ];
+  if (source.instructions) {
+    parts.push(source.instructions, "");
+  }
+  parts.push(source.content);
+  return parts.join("\n");
+}
+function buildSteeringContent(source) {
+  const parts = [];
+  if (source.instructions) {
+    parts.push(source.instructions, "");
+  }
+  parts.push(source.content);
+  return parts.join("\n");
+}
+async function fetchRemoteSources(sources, hubDir, skillsDir, steeringDir) {
+  let skillCount = 0;
+  let steeringCount = 0;
+  const errors = [];
+  for (const source of sources) {
+    try {
+      const rawContent = await fetchSourceContent(source, hubDir);
+      const fetched = {
+        name: source.name,
+        type: source.type,
+        content: rawContent,
+        triggers: source.triggers,
+        instructions: source.instructions
+      };
+      if (source.type === "skill") {
+        const skillDir = join2(skillsDir, source.name);
+        await mkdir2(skillDir, { recursive: true });
+        const skillContent = buildSkillContent(fetched);
+        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(join2(steeringDir, `${source.name}.md`), steeringContent, "utf-8");
+        steeringCount++;
+        console.log(chalk2.green(`  \u2713 ${source.name} (steering)`));
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      errors.push(`${source.name}: ${msg}`);
+      console.log(chalk2.yellow(`  \u2717 ${source.name}: ${msg}`));
+    }
+  }
+  return { skills: skillCount, steering: steeringCount, errors };
+}
+
 // src/commands/generate.ts
 var HUB_DOCS_URL = "https://hub.arvore.com.br/llms-full.txt";
+async function syncRemoteSources(config, hubDir, skillsDir, steeringDir) {
+  if (!config.remote_sources?.length) return;
+  console.log(chalk3.blue("  Syncing remote sources..."));
+  const result = await fetchRemoteSources(config.remote_sources, hubDir, skillsDir, steeringDir);
+  if (result.skills > 0 || result.steering > 0) {
+    console.log(chalk3.green(`  Synced ${result.skills} skill(s) and ${result.steering} steering file(s) from remote sources`));
+  }
+  if (result.errors.length > 0) {
+    console.log(chalk3.yellow(`  ${result.errors.length} remote source(s) failed`));
+  }
+}
+function buildDesignSection(config) {
+  const design = config.design;
+  if (!design) return null;
+  const hasContent = design.skills?.length || design.libraries?.length || design.icons || design.instructions;
+  if (!hasContent) return null;
+  const parts = [];
+  parts.push(`
+## Design System`);
+  if (design.instructions) {
+    parts.push(`
+${design.instructions.trim()}`);
+  }
+  if (design.skills?.length) {
+    parts.push(`
+### Design Skills
+`);
+    parts.push(`The following skills contain design guidelines and should be consulted when working on UI:`);
+    for (const skill of design.skills) {
+      parts.push(`- \`${skill}\``);
+    }
+  }
+  if (design.libraries?.length) {
+    parts.push(`
+### UI Libraries
+`);
+    for (const lib of design.libraries) {
+      const refs = [];
+      if (lib.mcp) refs.push(`docs via \`${lib.mcp}\` MCP`);
+      if (lib.url) refs.push(`[docs](${lib.url})`);
+      if (lib.path) refs.push(`local docs at \`${lib.path}\``);
+      parts.push(`- **${lib.name}**${refs.length ? ` \u2014 ${refs.join(", ")}` : ""}`);
+    }
+  }
+  if (design.icons) {
+    parts.push(`
+### Icons
+`);
+    parts.push(`Icon library: **${design.icons}**. Always use this library for icons.`);
+  }
+  return parts.join("\n");
+}
 function stripFrontMatter(content) {
   const match = content.match(/^---\n[\s\S]*?\n---\n*/);
   if (match) return content.slice(match[0].length);
@@ -183,12 +488,12 @@ async function fetchHubDocsSkill(skillsDir) {
   try {
     const res = await fetch(HUB_DOCS_URL);
     if (!res.ok) {
-      console.log(chalk2.yellow(`  Could not fetch hub docs (${res.status}), skipping hub-docs skill`));
+      console.log(chalk3.yellow(`  Could not fetch hub docs (${res.status}), skipping hub-docs skill`));
       return;
     }
     const content = await res.text();
     const hubSkillDir = join3(skillsDir, "hub-docs");
-    await mkdir2(hubSkillDir, { recursive: true });
+    await mkdir3(hubSkillDir, { recursive: true });
     const skillContent = `---
 name: hub-docs
 description: Repo Hub (rhm) documentation. Use when working with hub.yaml, hub CLI commands, agent orchestration, MCP configuration, skills, workflows, or multi-repo workspace setup.
@@ -196,10 +501,10 @@ triggers: [hub, rhm, hub.yaml, generate, scan, setup, orchestrator, multi-repo,
 ---
 
 ${content}`;
-    await writeFile2(join3(hubSkillDir, "SKILL.md"), skillContent, "utf-8");
-    console.log(chalk2.green("  Fetched hub-docs skill from hub.arvore.com.br"));
+    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(chalk2.yellow(`  Could not fetch hub docs, skipping hub-docs skill`));
+    console.log(chalk3.yellow(`  Could not fetch hub docs, skipping hub-docs skill`));
   }
 }
 var HUB_MARKER_START = "# >>> hub-managed (do not edit this section)";
@@ -274,36 +579,36 @@ async function generateEditorCommands(config, hubDir, targetDir, editorName) {
   const commandsDir = join3(targetDir, "commands");
   let count = 0;
   if (config.commands_dir) {
-    const srcDir = resolve(hubDir, config.commands_dir);
+    const srcDir = resolve2(hubDir, config.commands_dir);
     try {
       const files = await readdir2(srcDir);
       const mdFiles = files.filter((f) => f.endsWith(".md"));
       if (mdFiles.length > 0) {
-        await mkdir2(commandsDir, { recursive: true });
+        await mkdir3(commandsDir, { recursive: true });
         for (const file of mdFiles) {
           await copyFile(join3(srcDir, file), join3(commandsDir, file));
           count++;
         }
       }
     } catch {
-      console.log(chalk2.yellow(`  Commands directory ${config.commands_dir} not found, skipping`));
+      console.log(chalk3.yellow(`  Commands directory ${config.commands_dir} not found, skipping`));
     }
   }
   if (config.commands) {
-    await mkdir2(commandsDir, { recursive: true });
+    await mkdir3(commandsDir, { recursive: true });
     for (const [name, filePath] of Object.entries(config.commands)) {
-      const src = resolve(hubDir, filePath);
+      const src = resolve2(hubDir, filePath);
       const dest = join3(commandsDir, name.endsWith(".md") ? name : `${name}.md`);
       try {
         await copyFile(src, dest);
         count++;
       } catch {
-        console.log(chalk2.yellow(`  Command file ${filePath} not found, skipping`));
+        console.log(chalk3.yellow(`  Command file ${filePath} not found, skipping`));
       }
     }
   }
   if (count > 0) {
-    console.log(chalk2.green(`  Copied ${count} commands to ${editorName}`));
+    console.log(chalk3.green(`  Copied ${count} commands to ${editorName}`));
   }
 }
 async function writeManagedFile(filePath, managedLines) {
@@ -315,21 +620,21 @@ async function writeManagedFile(filePath, managedLines) {
     if (startIdx !== -1 && endIdx !== -1) {
       const before = existing.substring(0, startIdx);
       const after = existing.substring(endIdx + HUB_MARKER_END.length);
-      await writeFile2(filePath, before + managedBlock + after, "utf-8");
+      await writeFile3(filePath, before + managedBlock + after, "utf-8");
       return;
     }
-    await writeFile2(filePath, managedBlock + "\n\n" + existing, "utf-8");
+    await writeFile3(filePath, managedBlock + "\n\n" + existing, "utf-8");
     return;
   }
-  await writeFile2(filePath, managedBlock + "\n", "utf-8");
+  await writeFile3(filePath, managedBlock + "\n", "utf-8");
 }
 async function generateCursor(config, hubDir) {
   const cursorDir = join3(hubDir, ".cursor");
-  await mkdir2(join3(cursorDir, "rules"), { recursive: true });
-  await mkdir2(join3(cursorDir, "agents"), { recursive: true });
+  await mkdir3(join3(cursorDir, "rules"), { recursive: true });
+  await mkdir3(join3(cursorDir, "agents"), { recursive: true });
   const gitignoreLines = buildGitignoreLines(config);
   await writeManagedFile(join3(hubDir, ".gitignore"), gitignoreLines);
-  console.log(chalk2.green("  Generated .gitignore"));
+  console.log(chalk3.green("  Generated .gitignore"));
   const cursorignoreLines = [
     "# Re-include repositories for AI context"
   ];
@@ -339,7 +644,7 @@ async function generateCursor(config, hubDir) {
   }
   cursorignoreLines.push("", "# Re-include tasks for agent collaboration", "!tasks/");
   await writeManagedFile(join3(hubDir, ".cursorignore"), cursorignoreLines);
-  console.log(chalk2.green("  Generated .cursorignore"));
+  console.log(chalk3.green("  Generated .cursorignore"));
   if (config.mcps?.length) {
     const mcpConfig = {};
     const upstreamSet = getUpstreamNames(config.mcps);
@@ -351,17 +656,17 @@ async function generateCursor(config, hubDir) {
         mcpConfig[mcp.name] = buildCursorMcpEntry(mcp);
       }
     }
-    await writeFile2(
+    await writeFile3(
       join3(cursorDir, "mcp.json"),
       JSON.stringify({ mcpServers: mcpConfig }, null, 2) + "\n",
       "utf-8"
     );
-    console.log(chalk2.green("  Generated .cursor/mcp.json"));
+    console.log(chalk3.green("  Generated .cursor/mcp.json"));
   }
   const orchestratorRule = buildOrchestratorRule(config);
-  await writeFile2(join3(cursorDir, "rules", "orchestrator.mdc"), orchestratorRule, "utf-8");
-  console.log(chalk2.green("  Generated .cursor/rules/orchestrator.mdc"));
-  const hubSteeringDirCursor = resolve(hubDir, "steering");
+  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"));
@@ -375,29 +680,29 @@ alwaysApply: true
 ---
 
 ${content}`;
-      await writeFile2(join3(cursorDir, "rules", mdcName), mdcContent, "utf-8");
+      await writeFile3(join3(cursorDir, "rules", mdcName), mdcContent, "utf-8");
     }
     if (mdFiles.length > 0) {
-      console.log(chalk2.green(`  Copied ${mdFiles.length} steering files to .cursor/rules/`));
+      console.log(chalk3.green(`  Copied ${mdFiles.length} steering files to .cursor/rules/`));
     }
   } catch {
   }
-  const agentsDir = resolve(hubDir, "agents");
+  const agentsDir = resolve2(hubDir, "agents");
   try {
     const agentFiles = await readdir2(agentsDir);
     const mdFiles = agentFiles.filter((f) => f.endsWith(".md"));
     for (const file of mdFiles) {
       await copyFile(join3(agentsDir, file), join3(cursorDir, "agents", file));
     }
-    console.log(chalk2.green(`  Copied ${mdFiles.length} agent definitions`));
+    console.log(chalk3.green(`  Copied ${mdFiles.length} agent definitions`));
   } catch {
-    console.log(chalk2.yellow("  No agents/ directory found, skipping agent copy"));
+    console.log(chalk3.yellow("  No agents/ directory found, skipping agent copy"));
   }
-  const skillsDir = resolve(hubDir, "skills");
+  const skillsDir = resolve2(hubDir, "skills");
   try {
     const skillFolders = await readdir2(skillsDir);
     const cursorSkillsDir = join3(cursorDir, "skills");
-    await mkdir2(cursorSkillsDir, { recursive: true });
+    await mkdir3(cursorSkillsDir, { recursive: true });
     let count = 0;
     for (const folder of skillFolders) {
       const skillFile = join3(skillsDir, folder, "SKILL.md");
@@ -411,22 +716,23 @@ ${content}`;
       }
     }
     if (count > 0) {
-      console.log(chalk2.green(`  Copied ${count} skills`));
+      console.log(chalk3.green(`  Copied ${count} skills`));
     }
   } catch {
   }
   const cursorSkillsDirForDocs = join3(cursorDir, "skills");
-  await mkdir2(cursorSkillsDirForDocs, { recursive: true });
+  await mkdir3(cursorSkillsDirForDocs, { recursive: true });
   await fetchHubDocsSkill(cursorSkillsDirForDocs);
+  await syncRemoteSources(config, hubDir, join3(cursorDir, "skills"), join3(cursorDir, "rules"));
   if (config.hooks) {
     const cursorHooks = buildCursorHooks(config.hooks);
     if (cursorHooks) {
-      await writeFile2(
+      await writeFile3(
         join3(cursorDir, "hooks.json"),
         JSON.stringify(cursorHooks, null, 2) + "\n",
         "utf-8"
       );
-      console.log(chalk2.green("  Generated .cursor/hooks.json"));
+      console.log(chalk3.green("  Generated .cursor/hooks.json"));
     }
   }
   await generateEditorCommands(config, hubDir, cursorDir, ".cursor/commands/");
@@ -667,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(`
@@ -683,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) {
@@ -786,6 +1106,8 @@ This workspace has a team memory knowledge base available via the \`team-memory\
 
 Available tools: \`search_memories\`, \`get_memory\`, \`add_memory\`, \`list_memories\`, \`archive_memory\`, \`remove_memory\`.`);
   }
+  const designSectionOpenCode = buildDesignSection(config);
+  if (designSectionOpenCode) sections.push(designSectionOpenCode);
   sections.push(`
 ## Troubleshooting and Debugging
 
@@ -887,28 +1209,28 @@ If any validation agent leaves comments requiring fixes, call the relevant codin
 }
 async function generateOpenCode(config, hubDir) {
   const opencodeDir = join3(hubDir, ".opencode");
-  await mkdir2(join3(opencodeDir, "agents"), { recursive: true });
-  await mkdir2(join3(opencodeDir, "rules"), { recursive: true });
-  await mkdir2(join3(opencodeDir, "skills"), { recursive: true });
-  await mkdir2(join3(opencodeDir, "commands"), { recursive: true });
-  await mkdir2(join3(opencodeDir, "plugins"), { recursive: true });
+  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(join3(hubDir, ".gitignore"), gitignoreLines);
-  console.log(chalk2.green("  Generated .gitignore"));
+  console.log(chalk3.green("  Generated .gitignore"));
   const orchestratorRule = buildOpenCodeOrchestratorRule(config);
-  await writeFile2(join3(opencodeDir, "rules", "orchestrator.md"), orchestratorRule + "\n", "utf-8");
-  console.log(chalk2.green("  Generated .opencode/rules/orchestrator.md"));
-  const hubSteeringDirOC = resolve(hubDir, "steering");
+  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 readFile3(join3(hubSteeringDirOC, file), "utf-8");
       const content = stripFrontMatter(raw);
-      await writeFile2(join3(opencodeDir, "rules", file), content, "utf-8");
+      await writeFile3(join3(opencodeDir, "rules", file), content, "utf-8");
     }
     if (mdFiles.length > 0) {
-      console.log(chalk2.green(`  Copied ${mdFiles.length} steering files to .opencode/rules/`));
+      console.log(chalk3.green(`  Copied ${mdFiles.length} steering files to .opencode/rules/`));
     }
   } catch {
   }
@@ -929,13 +1251,13 @@ async function generateOpenCode(config, hubDir) {
     opencodeConfig.mcp = mcpConfig;
   }
   opencodeConfig.instructions = [".opencode/rules/*.md"];
-  await writeFile2(
+  await writeFile3(
     join3(hubDir, "opencode.json"),
     JSON.stringify(opencodeConfig, null, 2) + "\n",
     "utf-8"
   );
-  console.log(chalk2.green("  Generated opencode.json"));
-  const agentsDir = resolve(hubDir, "agents");
+  console.log(chalk3.green("  Generated opencode.json"));
+  const agentsDir = resolve2(hubDir, "agents");
   try {
     const agentFiles = await readdir2(agentsDir);
     const mdFiles = agentFiles.filter((f) => f.endsWith(".md"));
@@ -943,13 +1265,13 @@ async function generateOpenCode(config, hubDir) {
       const content = await readFile3(join3(agentsDir, file), "utf-8");
       const agentName = file.replace(/\.md$/, "");
       const converted = buildOpenCodeAgentMarkdown(agentName, content);
-      await writeFile2(join3(opencodeDir, "agents", file), converted, "utf-8");
+      await writeFile3(join3(opencodeDir, "agents", file), converted, "utf-8");
     }
-    console.log(chalk2.green(`  Copied ${mdFiles.length} agents to .opencode/agents/`));
+    console.log(chalk3.green(`  Copied ${mdFiles.length} agents to .opencode/agents/`));
   } catch {
-    console.log(chalk2.yellow("  No agents/ directory found, skipping agent copy"));
+    console.log(chalk3.yellow("  No agents/ directory found, skipping agent copy"));
   }
-  const skillsDir = resolve(hubDir, "skills");
+  const skillsDir = resolve2(hubDir, "skills");
   try {
     const skillFolders = await readdir2(skillsDir);
     let count = 0;
@@ -963,17 +1285,18 @@ async function generateOpenCode(config, hubDir) {
       }
     }
     if (count > 0) {
-      console.log(chalk2.green(`  Copied ${count} skills to .opencode/skills/`));
+      console.log(chalk3.green(`  Copied ${count} skills to .opencode/skills/`));
     }
   } catch {
   }
   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 writeFile2(join3(opencodeDir, "plugins", "hub-hooks.js"), plugin, "utf-8");
-      console.log(chalk2.green("  Generated .opencode/plugins/hub-hooks.js"));
+      await writeFile3(join3(opencodeDir, "plugins", "hub-hooks.js"), plugin, "utf-8");
+      console.log(chalk3.green("  Generated .opencode/plugins/hub-hooks.js"));
     }
   }
   await generateVSCodeSettings(config, hubDir);
@@ -1076,6 +1399,8 @@ This workspace has a team memory knowledge base available via the \`team-memory\
 
 Available tools: \`search_memories\`, \`get_memory\`, \`add_memory\`, \`list_memories\`, \`archive_memory\`, \`remove_memory\`.`);
   }
+  const designSectionKiro = buildDesignSection(config);
+  if (designSectionKiro) sections.push(designSectionKiro);
   sections.push(`
 ## Troubleshooting and Debugging
 
@@ -1262,6 +1587,8 @@ This workspace has a team memory knowledge base available via the \`team-memory\
 
 Available tools: \`search_memories\`, \`get_memory\`, \`add_memory\`, \`list_memories\`, \`archive_memory\`, \`remove_memory\`.`);
   }
+  const designSectionCursor = buildDesignSection(config);
+  if (designSectionCursor) sections.push(designSectionCursor);
   sections.push(`
 ## Troubleshooting and Debugging
 
@@ -1442,27 +1769,27 @@ function formatAction(action) {
 }
 async function generateClaudeCode(config, hubDir) {
   const claudeDir = join3(hubDir, ".claude");
-  await mkdir2(join3(claudeDir, "agents"), { recursive: true });
+  await mkdir3(join3(claudeDir, "agents"), { recursive: true });
   const orchestratorRule = buildOrchestratorRule(config);
   const cleanedOrchestrator = orchestratorRule.replace(/^---[\s\S]*?---\n/m, "").trim();
   const claudeMdSections = [];
   claudeMdSections.push(cleanedOrchestrator);
-  const agentsDir = resolve(hubDir, "agents");
+  const agentsDir = resolve2(hubDir, "agents");
   try {
     const agentFiles = await readdir2(agentsDir);
     const mdFiles = agentFiles.filter((f) => f.endsWith(".md"));
     for (const file of mdFiles) {
       await copyFile(join3(agentsDir, file), join3(claudeDir, "agents", file));
     }
-    console.log(chalk2.green(`  Copied ${mdFiles.length} agents to .claude/agents/`));
+    console.log(chalk3.green(`  Copied ${mdFiles.length} agents to .claude/agents/`));
   } catch {
-    console.log(chalk2.yellow("  No agents/ directory found, skipping agent copy"));
+    console.log(chalk3.yellow("  No agents/ directory found, skipping agent copy"));
   }
-  const skillsDir = resolve(hubDir, "skills");
+  const skillsDir = resolve2(hubDir, "skills");
   try {
     const skillFolders = await readdir2(skillsDir);
     const claudeSkillsDir = join3(claudeDir, "skills");
-    await mkdir2(claudeSkillsDir, { recursive: true });
+    await mkdir3(claudeSkillsDir, { recursive: true });
     let count = 0;
     for (const folder of skillFolders) {
       const skillFile = join3(skillsDir, folder, "SKILL.md");
@@ -1476,14 +1803,15 @@ async function generateClaudeCode(config, hubDir) {
       }
     }
     if (count > 0) {
-      console.log(chalk2.green(`  Copied ${count} skills to .claude/skills/`));
+      console.log(chalk3.green(`  Copied ${count} skills to .claude/skills/`));
     }
   } catch {
   }
   const claudeSkillsDirForDocs = join3(claudeDir, "skills");
-  await mkdir2(claudeSkillsDirForDocs, { recursive: true });
+  await mkdir3(claudeSkillsDirForDocs, { recursive: true });
   await fetchHubDocsSkill(claudeSkillsDirForDocs);
-  const hubSteeringDirClaude = resolve(hubDir, "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"));
@@ -1495,12 +1823,12 @@ async function generateClaudeCode(config, hubDir) {
       }
     }
     if (mdFiles.length > 0) {
-      console.log(chalk2.green(`  Appended ${mdFiles.length} steering files to CLAUDE.md`));
+      console.log(chalk3.green(`  Appended ${mdFiles.length} steering files to CLAUDE.md`));
     }
   } catch {
   }
-  await writeFile2(join3(hubDir, "CLAUDE.md"), claudeMdSections.join("\n\n"), "utf-8");
-  console.log(chalk2.green("  Generated CLAUDE.md"));
+  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 = {};
     const upstreamSet = getUpstreamNames(config.mcps);
@@ -1512,12 +1840,12 @@ async function generateClaudeCode(config, hubDir) {
         mcpJson[mcp.name] = buildClaudeCodeMcpEntry(mcp);
       }
     }
-    await writeFile2(
+    await writeFile3(
       join3(hubDir, ".mcp.json"),
       JSON.stringify({ mcpServers: mcpJson }, null, 2) + "\n",
       "utf-8"
     );
-    console.log(chalk2.green("  Generated .mcp.json"));
+    console.log(chalk3.green("  Generated .mcp.json"));
   }
   const mcpServerNames = config.mcps?.map((m) => m.name) || [];
   const claudeSettings = {
@@ -1555,22 +1883,22 @@ async function generateClaudeCode(config, hubDir) {
       claudeSettings.hooks = claudeHooks;
     }
   }
-  await writeFile2(
+  await writeFile3(
     join3(claudeDir, "settings.json"),
     JSON.stringify(claudeSettings, null, 2) + "\n",
     "utf-8"
   );
-  console.log(chalk2.green("  Generated .claude/settings.json"));
+  console.log(chalk3.green("  Generated .claude/settings.json"));
   const gitignoreLines = buildGitignoreLines(config);
   await writeManagedFile(join3(hubDir, ".gitignore"), gitignoreLines);
-  console.log(chalk2.green("  Generated .gitignore"));
+  console.log(chalk3.green("  Generated .gitignore"));
 }
 async function generateKiro(config, hubDir) {
   const kiroDir = join3(hubDir, ".kiro");
   const steeringDir = join3(kiroDir, "steering");
   const settingsDir = join3(kiroDir, "settings");
-  await mkdir2(steeringDir, { recursive: true });
-  await mkdir2(settingsDir, { recursive: true });
+  await mkdir3(steeringDir, { recursive: true });
+  await mkdir3(settingsDir, { recursive: true });
   let mode = await getKiroMode(hubDir);
   if (!mode) {
     const { kiroMode } = await inquirer.prompt([
@@ -1586,20 +1914,20 @@ async function generateKiro(config, hubDir) {
     ]);
     mode = kiroMode;
     await saveKiroMode(hubDir, mode);
-    console.log(chalk2.dim(`  Saved Kiro mode: ${mode}`));
+    console.log(chalk3.dim(`  Saved Kiro mode: ${mode}`));
   } else {
-    console.log(chalk2.dim(`  Using saved Kiro mode: ${mode}`));
+    console.log(chalk3.dim(`  Using saved Kiro mode: ${mode}`));
   }
   const gitignoreLines = buildGitignoreLines(config);
   await writeManagedFile(join3(hubDir, ".gitignore"), gitignoreLines);
-  console.log(chalk2.green("  Generated .gitignore"));
+  console.log(chalk3.green("  Generated .gitignore"));
   const kiroRule = buildKiroOrchestratorRule(config);
   const kiroOrchestrator = buildKiroSteeringContent(kiroRule, "always", { name: "orchestrator" });
-  await writeFile2(join3(steeringDir, "orchestrator.md"), kiroOrchestrator, "utf-8");
-  console.log(chalk2.green("  Generated .kiro/steering/orchestrator.md"));
-  await writeFile2(join3(hubDir, "AGENTS.md"), kiroRule + "\n", "utf-8");
-  console.log(chalk2.green("  Generated AGENTS.md"));
-  const hubSteeringDir = resolve(hubDir, "steering");
+  await writeFile3(join3(steeringDir, "orchestrator.md"), kiroOrchestrator, "utf-8");
+  console.log(chalk3.green("  Generated .kiro/steering/orchestrator.md"));
+  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"));
@@ -1635,33 +1963,33 @@ async function generateKiro(config, hubDir) {
         }
       }
       const kiroSteering = buildKiroSteeringContent(content, inclusion, meta);
-      await writeFile2(destPath, kiroSteering, "utf-8");
+      await writeFile3(destPath, kiroSteering, "utf-8");
     }
     if (mdFiles.length > 0) {
-      console.log(chalk2.green(`  Copied ${mdFiles.length} steering files to .kiro/steering/`));
+      console.log(chalk3.green(`  Copied ${mdFiles.length} steering files to .kiro/steering/`));
     }
   } catch {
   }
-  const agentsDir = resolve(hubDir, "agents");
+  const agentsDir = resolve2(hubDir, "agents");
   try {
     const kiroAgentsDir = join3(kiroDir, "agents");
-    await mkdir2(kiroAgentsDir, { recursive: true });
+    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 readFile3(join3(agentsDir, file), "utf-8");
       const kiroAgent = buildKiroAgentContent(agentContent);
-      await writeFile2(join3(kiroAgentsDir, file), kiroAgent, "utf-8");
+      await writeFile3(join3(kiroAgentsDir, file), kiroAgent, "utf-8");
     }
-    console.log(chalk2.green(`  Copied ${mdFiles.length} agents to .kiro/agents/`));
+    console.log(chalk3.green(`  Copied ${mdFiles.length} agents to .kiro/agents/`));
   } catch {
-    console.log(chalk2.yellow("  No agents/ directory found, skipping agent copy"));
+    console.log(chalk3.yellow("  No agents/ directory found, skipping agent copy"));
   }
-  const skillsDir = resolve(hubDir, "skills");
+  const skillsDir = resolve2(hubDir, "skills");
   try {
     const skillFolders = await readdir2(skillsDir);
     const kiroSkillsDir = join3(kiroDir, "skills");
-    await mkdir2(kiroSkillsDir, { recursive: true });
+    await mkdir3(kiroSkillsDir, { recursive: true });
     let count = 0;
     for (const folder of skillFolders) {
       const skillFile = join3(skillsDir, folder, "SKILL.md");
@@ -1675,13 +2003,14 @@ async function generateKiro(config, hubDir) {
       }
     }
     if (count > 0) {
-      console.log(chalk2.green(`  Copied ${count} skills to .kiro/skills/`));
+      console.log(chalk3.green(`  Copied ${count} skills to .kiro/skills/`));
     }
   } catch {
   }
   const kiroSkillsDirForDocs = join3(kiroDir, "skills");
-  await mkdir2(kiroSkillsDirForDocs, { recursive: true });
+  await mkdir3(kiroSkillsDirForDocs, { recursive: true });
   await fetchHubDocsSkill(kiroSkillsDirForDocs);
+  await syncRemoteSources(config, hubDir, join3(kiroDir, "skills"), steeringDir);
   if (config.mcps?.length) {
     const mcpConfig = {};
     const upstreamSet = getUpstreamNames(config.mcps);
@@ -1697,12 +2026,12 @@ async function generateKiro(config, hubDir) {
     const mcpJsonPath = join3(settingsDir, "mcp.json");
     const disabledState = await readExistingMcpDisabledState(mcpJsonPath);
     applyDisabledState(mcpConfig, disabledState);
-    await writeFile2(
+    await writeFile3(
       mcpJsonPath,
       JSON.stringify({ mcpServers: mcpConfig }, null, 2) + "\n",
       "utf-8"
     );
-    console.log(chalk2.green("  Generated .kiro/settings/mcp.json"));
+    console.log(chalk3.green("  Generated .kiro/settings/mcp.json"));
   }
   if (config.hooks) {
     const hookNotes = [];
@@ -1714,10 +2043,10 @@ async function generateKiro(config, hubDir) {
       }
     }
     if (hookNotes.length > 0) {
-      console.log(chalk2.yellow(`  Note: Kiro hooks are managed via the Kiro panel UI.`));
-      console.log(chalk2.yellow(`  The following hooks should be configured manually:`));
+      console.log(chalk3.yellow(`  Note: Kiro hooks are managed via the Kiro panel UI.`));
+      console.log(chalk3.yellow(`  The following hooks should be configured manually:`));
       for (const note of hookNotes) {
-        console.log(chalk2.yellow(`    ${note}`));
+        console.log(chalk3.yellow(`    ${note}`));
       }
     }
   }
@@ -1725,7 +2054,7 @@ async function generateKiro(config, hubDir) {
 }
 async function generateVSCodeSettings(config, hubDir) {
   const vscodeDir = join3(hubDir, ".vscode");
-  await mkdir2(vscodeDir, { recursive: true });
+  await mkdir3(vscodeDir, { recursive: true });
   const settingsPath = join3(vscodeDir, "settings.json");
   let existing = {};
   if (existsSync2(settingsPath)) {
@@ -1742,8 +2071,8 @@ async function generateVSCodeSettings(config, hubDir) {
     "git.detectSubmodulesLimit": Math.max(config.repos.length * 2, 20)
   };
   const merged = { ...existing, ...managed };
-  await writeFile2(settingsPath, JSON.stringify(merged, null, 2) + "\n", "utf-8");
-  console.log(chalk2.green("  Generated .vscode/settings.json (git multi-repo detection)"));
+  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 = join3(hubDir, workspaceFile);
   let existingWorkspace = {};
@@ -1795,8 +2124,8 @@ async function generateVSCodeSettings(config, hubDir) {
     folders,
     settings: existingWorkspace.settings || {}
   };
-  await writeFile2(workspacePath, JSON.stringify(workspace, null, "	") + "\n", "utf-8");
-  console.log(chalk2.green(`  Generated ${workspaceFile}`));
+  await writeFile3(workspacePath, JSON.stringify(workspace, null, "	") + "\n", "utf-8");
+  console.log(chalk3.green(`  Generated ${workspaceFile}`));
 }
 function extractEnvVarsByMcp(mcps) {
   const envVarPattern = /\$\{env:([^}]+)\}/;
@@ -1819,9 +2148,7 @@ function extractEnvVarsByMcp(mcps) {
   return groups;
 }
 async function generateEnvExample(config, hubDir) {
-  if (!config.mcps?.length) return;
-  const groups = extractEnvVarsByMcp(config.mcps);
-  if (groups.length === 0) return;
+  const groups = extractEnvVarsByMcp(config.mcps || []);
   let totalVars = 0;
   const lines = [];
   const seen = /* @__PURE__ */ new Set();
@@ -1836,8 +2163,16 @@ async function generateEnvExample(config, hubDir) {
     }
     totalVars += uniqueVars.length;
   }
-  await writeFile2(join3(hubDir, ".env.example"), lines.join("\n") + "\n", "utf-8");
-  console.log(chalk2.green(`  Generated .env.example (${totalVars} vars)`));
+  const hasNotionSources = config.remote_sources?.some((s) => s.notion_page);
+  if (hasNotionSources && !seen.has("NOTION_API_KEY")) {
+    if (lines.length > 0) lines.push("");
+    lines.push("# Remote Sources (Notion)");
+    lines.push("NOTION_API_KEY=");
+    totalVars++;
+  }
+  if (totalVars === 0) return;
+  await writeFile3(join3(hubDir, ".env.example"), lines.join("\n") + "\n", "utf-8");
+  console.log(chalk3.green(`  Generated .env.example (${totalVars} vars)`));
 }
 function buildGitignoreLines(config) {
   const lines = [
@@ -1924,14 +2259,14 @@ var generateCommand = new Command("generate").description("Generate editor-speci
   if (opts.check) {
     const result = await checkOutdated(hubDir);
     if (result.reason === "no-previous-generate") {
-      console.log(chalk2.yellow("No previous generate found. Run 'hub generate' first."));
+      console.log(chalk3.yellow("No previous generate found. Run 'hub generate' first."));
       process.exit(1);
     }
     if (result.outdated) {
-      console.log(chalk2.yellow("Generated configs are outdated. Run 'hub generate' to update."));
+      console.log(chalk3.yellow("Generated configs are outdated. Run 'hub generate' to update."));
       process.exit(1);
     }
-    console.log(chalk2.green("Generated configs are up to date."));
+    console.log(chalk3.green("Generated configs are up to date."));
     return;
   }
   const config = await loadHubConfig(hubDir);
@@ -1940,42 +2275,50 @@ var generateCommand = new Command("generate").description("Generate editor-speci
       (m) => m.name === "team-memory" || m.package === "@arvoretech/memory-mcp"
     );
     if (!hasMemoryMcp) {
-      console.log(chalk2.red(`
+      console.log(chalk3.red(`
   Error: 'memory' is configured but no memory MCP is declared in 'mcps'.
 `));
-      console.log(chalk2.yellow(`  Add this to your hub.yaml:
+      console.log(chalk3.yellow(`  Add this to your hub.yaml:
 `));
-      console.log(chalk2.dim(`  mcps:`));
-      console.log(chalk2.dim(`    - name: team-memory`));
-      console.log(chalk2.dim(`      package: "@arvoretech/memory-mcp"`));
-      console.log(chalk2.dim(`      env:`));
-      console.log(chalk2.dim(`        MEMORY_PATH: ${config.memory.path || "./memories"}
+      console.log(chalk3.dim(`  mcps:`));
+      console.log(chalk3.dim(`    - name: team-memory`));
+      console.log(chalk3.dim(`      package: "@arvoretech/memory-mcp"`));
+      console.log(chalk3.dim(`      env:`));
+      console.log(chalk3.dim(`        MEMORY_PATH: ${config.memory.path || "./memories"}
 `));
       process.exit(1);
     }
   }
+  if (config.remote_sources?.length) {
+    const hasNotionSources = config.remote_sources.some((s) => s.notion_page);
+    if (hasNotionSources && !process.env.NOTION_API_KEY && !process.env.NOTION_TOKEN) {
+      console.log(chalk3.yellow(`
+  Warning: remote_sources include Notion pages but NOTION_API_KEY is not set.`));
+      console.log(chalk3.yellow(`  Notion sources will be skipped. Set NOTION_API_KEY in your .env or environment.
+`));
+    }
+  }
   const editorKey = await resolveEditor(opts);
   const generator = generators[editorKey];
   if (!generator) {
     console.log(
-      chalk2.red(`Unknown editor: ${editorKey}. Available: ${Object.keys(generators).join(", ")}`)
+      chalk3.red(`Unknown editor: ${editorKey}. Available: ${Object.keys(generators).join(", ")}`)
     );
     return;
   }
   if (opts.editor || opts.resetEditor) {
-    console.log(chalk2.dim(`  Saving editor preference: ${generator.name}`));
+    console.log(chalk3.dim(`  Saving editor preference: ${generator.name}`));
   }
-  console.log(chalk2.blue(`
+  console.log(chalk3.blue(`
 Generating ${generator.name} configuration
 `));
   await generator.generate(config, hubDir);
   await generateEnvExample(config, hubDir);
   await saveGenerateState(hubDir, editorKey);
-  console.log(chalk2.green("\nDone!\n"));
+  console.log(chalk3.green("\nDone!\n"));
 });
 
 export {
-  loadHubConfig,
   generators,
   generateCommand,
   checkAndAutoRegenerate