@arvoretech/hub 0.8.1 → 0.9.0

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

@@ -1,9 +1,9 @@
 // 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 readFile4, cp } from "fs/promises";
+import { join as join4, resolve as resolve2 } from "path";
+import chalk3 from "chalk";
 import inquirer from "inquirer";
 
 // src/core/hub-config.ts
@@ -121,7 +121,7 @@ async function checkAndAutoRegenerate(hubDir) {
       return;
     }
     console.log(chalk.yellow("\n  Detected outdated configs, auto-regenerating..."));
-    const { generators: generators2 } = await import("./generate-BYB47MCP.js");
+    const { generators: generators2 } = await import("./generate-H4YM3WTV.js");
     const generator = generators2[result.editor];
     if (!generator) {
       console.log(chalk.red(`  Unknown editor '${result.editor}' in cache. Run 'hub generate' manually.`));
@@ -137,8 +137,317 @@ 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 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 readFile3(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 = join3(skillsDir, source.name);
+        await mkdir2(skillDir, { recursive: true });
+        const skillContent = buildSkillContent(fetched);
+        await writeFile2(join3(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");
+        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);
@@ -161,7 +470,7 @@ async function readExistingMcpDisabledState(mcpJsonPath) {
   const disabledState = {};
   if (!existsSync2(mcpJsonPath)) return disabledState;
   try {
-    const content = JSON.parse(await readFile3(mcpJsonPath, "utf-8"));
+    const content = JSON.parse(await readFile4(mcpJsonPath, "utf-8"));
     const servers = content.mcpServers || content.mcp || {};
     for (const [name, config] of Object.entries(servers)) {
       if (typeof config.disabled === "boolean") {
@@ -183,12 +492,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 });
+    const hubSkillDir = join4(skillsDir, "hub-docs");
+    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 +505,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(join4(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)";
@@ -271,65 +580,65 @@ function buildClaudeHooks(hooks) {
   return claudeHooks;
 }
 async function generateEditorCommands(config, hubDir, targetDir, editorName) {
-  const commandsDir = join3(targetDir, "commands");
+  const commandsDir = join4(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));
+          await copyFile(join4(srcDir, file), join4(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 dest = join3(commandsDir, name.endsWith(".md") ? name : `${name}.md`);
+      const src = resolve2(hubDir, filePath);
+      const dest = join4(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) {
   const managedBlock = [HUB_MARKER_START, ...managedLines, HUB_MARKER_END].join("\n");
   if (existsSync2(filePath)) {
-    const existing = await readFile3(filePath, "utf-8");
+    const existing = await readFile4(filePath, "utf-8");
     const startIdx = existing.indexOf(HUB_MARKER_START);
     const endIdx = existing.indexOf(HUB_MARKER_END);
     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 });
+  const cursorDir = join4(hubDir, ".cursor");
+  await mkdir3(join4(cursorDir, "rules"), { recursive: true });
+  await mkdir3(join4(cursorDir, "agents"), { recursive: true });
   const gitignoreLines = buildGitignoreLines(config);
-  await writeManagedFile(join3(hubDir, ".gitignore"), gitignoreLines);
-  console.log(chalk2.green("  Generated .gitignore"));
+  await writeManagedFile(join4(hubDir, ".gitignore"), gitignoreLines);
+  console.log(chalk3.green("  Generated .gitignore"));
   const cursorignoreLines = [
     "# Re-include repositories for AI context"
   ];
@@ -338,8 +647,8 @@ async function generateCursor(config, hubDir) {
     cursorignoreLines.push(`!${repoDir}/`);
   }
   cursorignoreLines.push("", "# Re-include tasks for agent collaboration", "!tasks/");
-  await writeManagedFile(join3(hubDir, ".cursorignore"), cursorignoreLines);
-  console.log(chalk2.green("  Generated .cursorignore"));
+  await writeManagedFile(join4(hubDir, ".cursorignore"), cursorignoreLines);
+  console.log(chalk3.green("  Generated .cursorignore"));
   if (config.mcps?.length) {
     const mcpConfig = {};
     const upstreamSet = getUpstreamNames(config.mcps);
@@ -351,22 +660,22 @@ async function generateCursor(config, hubDir) {
         mcpConfig[mcp.name] = buildCursorMcpEntry(mcp);
       }
     }
-    await writeFile2(
-      join3(cursorDir, "mcp.json"),
+    await writeFile3(
+      join4(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(join4(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 readFile3(join3(hubSteeringDirCursor, file), "utf-8");
+      const raw = await readFile4(join4(hubSteeringDirCursor, file), "utf-8");
       const content = stripFrontMatter(raw);
       const mdcName = file.replace(/\.md$/, ".mdc");
       const mdcContent = `---
@@ -375,58 +684,59 @@ alwaysApply: true
 ---
 
 ${content}`;
-      await writeFile2(join3(cursorDir, "rules", mdcName), mdcContent, "utf-8");
+      await writeFile3(join4(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));
+      await copyFile(join4(agentsDir, file), join4(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 });
+    const cursorSkillsDir = join4(cursorDir, "skills");
+    await mkdir3(cursorSkillsDir, { recursive: true });
     let count = 0;
     for (const folder of skillFolders) {
-      const skillFile = join3(skillsDir, folder, "SKILL.md");
+      const skillFile = join4(skillsDir, folder, "SKILL.md");
       try {
-        await readFile3(skillFile);
-        const srcDir = join3(skillsDir, folder);
-        const targetDir = join3(cursorSkillsDir, folder);
+        await readFile4(skillFile);
+        const srcDir = join4(skillsDir, folder);
+        const targetDir = join4(cursorSkillsDir, folder);
         await cp(srcDir, targetDir, { recursive: true });
         count++;
       } catch {
       }
     }
     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 });
+  const cursorSkillsDirForDocs = join4(cursorDir, "skills");
+  await mkdir3(cursorSkillsDirForDocs, { recursive: true });
   await fetchHubDocsSkill(cursorSkillsDirForDocs);
+  await syncRemoteSources(config, hubDir, join4(cursorDir, "skills"), join4(cursorDir, "rules"));
   if (config.hooks) {
     const cursorHooks = buildCursorHooks(config.hooks);
     if (cursorHooks) {
-      await writeFile2(
-        join3(cursorDir, "hooks.json"),
+      await writeFile3(
+        join4(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/");
@@ -786,6 +1096,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
 
@@ -886,29 +1198,29 @@ If any validation agent leaves comments requiring fixes, call the relevant codin
   return parts.join("\n");
 }
 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 });
+  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 gitignoreLines = buildGitignoreLines(config);
-  await writeManagedFile(join3(hubDir, ".gitignore"), gitignoreLines);
-  console.log(chalk2.green("  Generated .gitignore"));
+  await writeManagedFile(join4(hubDir, ".gitignore"), gitignoreLines);
+  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(join4(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 raw = await readFile4(join4(hubSteeringDirOC, file), "utf-8");
       const content = stripFrontMatter(raw);
-      await writeFile2(join3(opencodeDir, "rules", file), content, "utf-8");
+      await writeFile3(join4(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,51 +1241,52 @@ async function generateOpenCode(config, hubDir) {
     opencodeConfig.mcp = mcpConfig;
   }
   opencodeConfig.instructions = [".opencode/rules/*.md"];
-  await writeFile2(
-    join3(hubDir, "opencode.json"),
+  await writeFile3(
+    join4(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"));
     for (const file of mdFiles) {
-      const content = await readFile3(join3(agentsDir, file), "utf-8");
+      const content = await readFile4(join4(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(join4(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;
     for (const folder of skillFolders) {
-      const skillFile = join3(skillsDir, folder, "SKILL.md");
+      const skillFile = join4(skillsDir, folder, "SKILL.md");
       try {
-        await readFile3(skillFile);
-        await cp(join3(skillsDir, folder), join3(opencodeDir, "skills", folder), { recursive: true });
+        await readFile4(skillFile);
+        await cp(join4(skillsDir, folder), join4(opencodeDir, "skills", folder), { recursive: true });
         count++;
       } catch {
       }
     }
     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 fetchHubDocsSkill(join4(opencodeDir, "skills"));
+  await syncRemoteSources(config, hubDir, join4(opencodeDir, "skills"), join4(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(join4(opencodeDir, "plugins", "hub-hooks.js"), plugin, "utf-8");
+      console.log(chalk3.green("  Generated .opencode/plugins/hub-hooks.js"));
     }
   }
   await generateVSCodeSettings(config, hubDir);
@@ -1076,6 +1389,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 +1577,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
 
@@ -1441,66 +1758,67 @@ function formatAction(action) {
   return map[action] || action;
 }
 async function generateClaudeCode(config, hubDir) {
-  const claudeDir = join3(hubDir, ".claude");
-  await mkdir2(join3(claudeDir, "agents"), { recursive: true });
+  const claudeDir = join4(hubDir, ".claude");
+  await mkdir3(join4(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));
+      await copyFile(join4(agentsDir, file), join4(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 });
+    const claudeSkillsDir = join4(claudeDir, "skills");
+    await mkdir3(claudeSkillsDir, { recursive: true });
     let count = 0;
     for (const folder of skillFolders) {
-      const skillFile = join3(skillsDir, folder, "SKILL.md");
+      const skillFile = join4(skillsDir, folder, "SKILL.md");
       try {
-        await readFile3(skillFile);
-        const srcDir = join3(skillsDir, folder);
-        const targetDir = join3(claudeSkillsDir, folder);
+        await readFile4(skillFile);
+        const srcDir = join4(skillsDir, folder);
+        const targetDir = join4(claudeSkillsDir, folder);
         await cp(srcDir, targetDir, { recursive: true });
         count++;
       } catch {
       }
     }
     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 });
+  const claudeSkillsDirForDocs = join4(claudeDir, "skills");
+  await mkdir3(claudeSkillsDirForDocs, { recursive: true });
   await fetchHubDocsSkill(claudeSkillsDirForDocs);
-  const hubSteeringDirClaude = resolve(hubDir, "steering");
+  await syncRemoteSources(config, hubDir, join4(claudeDir, "skills"), join4(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 readFile3(join3(hubSteeringDirClaude, file), "utf-8");
+      const raw = await readFile4(join4(hubSteeringDirClaude, file), "utf-8");
       const content = stripFrontMatter(raw).trim();
       if (content) {
         claudeMdSections.push(content);
       }
     }
     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(join4(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 +1830,12 @@ async function generateClaudeCode(config, hubDir) {
         mcpJson[mcp.name] = buildClaudeCodeMcpEntry(mcp);
       }
     }
-    await writeFile2(
-      join3(hubDir, ".mcp.json"),
+    await writeFile3(
+      join4(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 +1873,22 @@ async function generateClaudeCode(config, hubDir) {
       claudeSettings.hooks = claudeHooks;
     }
   }
-  await writeFile2(
-    join3(claudeDir, "settings.json"),
+  await writeFile3(
+    join4(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"));
+  await writeManagedFile(join4(hubDir, ".gitignore"), gitignoreLines);
+  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 });
+  const kiroDir = join4(hubDir, ".kiro");
+  const steeringDir = join4(kiroDir, "steering");
+  const settingsDir = join4(kiroDir, "settings");
+  await mkdir3(steeringDir, { recursive: true });
+  await mkdir3(settingsDir, { recursive: true });
   let mode = await getKiroMode(hubDir);
   if (!mode) {
     const { kiroMode } = await inquirer.prompt([
@@ -1586,31 +1904,31 @@ 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"));
+  await writeManagedFile(join4(hubDir, ".gitignore"), gitignoreLines);
+  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(join4(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");
+  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 readFile3(join3(hubSteeringDir, file), "utf-8");
+      const raw = await readFile4(join4(hubSteeringDir, file), "utf-8");
       const content = stripFrontMatter(raw);
-      const destPath = join3(steeringDir, file);
+      const destPath = join4(steeringDir, file);
       let inclusion = "always";
       let meta;
       if (existsSync2(destPath)) {
-        const existingContent = await readFile3(destPath, "utf-8");
+        const existingContent = await readFile4(destPath, "utf-8");
         const existingFm = parseFrontMatter(existingContent);
         if (existingFm) {
           if (existingFm.inclusion === "auto" || existingFm.inclusion === "manual" || existingFm.inclusion === "fileMatch") {
@@ -1635,53 +1953,54 @@ 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 });
+    const kiroAgentsDir = join4(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 readFile3(join3(agentsDir, file), "utf-8");
+      const agentContent = await readFile4(join4(agentsDir, file), "utf-8");
       const kiroAgent = buildKiroAgentContent(agentContent);
-      await writeFile2(join3(kiroAgentsDir, file), kiroAgent, "utf-8");
+      await writeFile3(join4(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 });
+    const kiroSkillsDir = join4(kiroDir, "skills");
+    await mkdir3(kiroSkillsDir, { recursive: true });
     let count = 0;
     for (const folder of skillFolders) {
-      const skillFile = join3(skillsDir, folder, "SKILL.md");
+      const skillFile = join4(skillsDir, folder, "SKILL.md");
       try {
-        await readFile3(skillFile);
-        const srcDir = join3(skillsDir, folder);
-        const targetDir = join3(kiroSkillsDir, folder);
+        await readFile4(skillFile);
+        const srcDir = join4(skillsDir, folder);
+        const targetDir = join4(kiroSkillsDir, folder);
         await cp(srcDir, targetDir, { recursive: true });
         count++;
       } catch {
       }
     }
     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 });
+  const kiroSkillsDirForDocs = join4(kiroDir, "skills");
+  await mkdir3(kiroSkillsDirForDocs, { recursive: true });
   await fetchHubDocsSkill(kiroSkillsDirForDocs);
+  await syncRemoteSources(config, hubDir, join4(kiroDir, "skills"), steeringDir);
   if (config.mcps?.length) {
     const mcpConfig = {};
     const upstreamSet = getUpstreamNames(config.mcps);
@@ -1694,15 +2013,15 @@ async function generateKiro(config, hubDir) {
         mcpConfig[mcp.name] = buildKiroMcpEntry(mcp, mode);
       }
     }
-    const mcpJsonPath = join3(settingsDir, "mcp.json");
+    const mcpJsonPath = join4(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,23 +2033,23 @@ 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}`));
       }
     }
   }
   await generateVSCodeSettings(config, hubDir);
 }
 async function generateVSCodeSettings(config, hubDir) {
-  const vscodeDir = join3(hubDir, ".vscode");
-  await mkdir2(vscodeDir, { recursive: true });
-  const settingsPath = join3(vscodeDir, "settings.json");
+  const vscodeDir = join4(hubDir, ".vscode");
+  await mkdir3(vscodeDir, { recursive: true });
+  const settingsPath = join4(vscodeDir, "settings.json");
   let existing = {};
   if (existsSync2(settingsPath)) {
     try {
-      const raw = await readFile3(settingsPath, "utf-8");
+      const raw = await readFile4(settingsPath, "utf-8");
       existing = JSON.parse(raw);
     } catch {
       existing = {};
@@ -1742,14 +2061,14 @@ 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);
+  const workspacePath = join4(hubDir, workspaceFile);
   let existingWorkspace = {};
   if (existsSync2(workspacePath)) {
     try {
-      const raw = await readFile3(workspacePath, "utf-8");
+      const raw = await readFile4(workspacePath, "utf-8");
       existingWorkspace = JSON.parse(raw);
     } catch {
       existingWorkspace = {};
@@ -1759,7 +2078,7 @@ async function generateVSCodeSettings(config, hubDir) {
     const existing2 = files.find((f) => f.endsWith(".code-workspace"));
     if (existing2) {
       try {
-        const raw = await readFile3(join3(hubDir, existing2), "utf-8");
+        const raw = await readFile4(join4(hubDir, existing2), "utf-8");
         existingWorkspace = JSON.parse(raw);
       } catch {
         existingWorkspace = {};
@@ -1795,8 +2114,55 @@ 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:([^}]+)\}/;
+  const groups = [];
+  for (const mcp of mcps) {
+    if (!mcp.env) continue;
+    const vars = [];
+    const seenInGroup = /* @__PURE__ */ new Set();
+    for (const value of Object.values(mcp.env)) {
+      const match = envVarPattern.exec(value);
+      if (match && !seenInGroup.has(match[1])) {
+        seenInGroup.add(match[1]);
+        vars.push(match[1]);
+      }
+    }
+    if (vars.length > 0) {
+      groups.push({ name: mcp.name, vars: vars.sort() });
+    }
+  }
+  return groups;
+}
+async function generateEnvExample(config, hubDir) {
+  const groups = extractEnvVarsByMcp(config.mcps || []);
+  let totalVars = 0;
+  const lines = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const group of groups) {
+    const uniqueVars = group.vars.filter((v) => !seen.has(v));
+    if (uniqueVars.length === 0) continue;
+    for (const v of uniqueVars) seen.add(v);
+    if (lines.length > 0) lines.push("");
+    lines.push(`# ${group.name}`);
+    for (const v of uniqueVars) {
+      lines.push(`${v}=`);
+    }
+    totalVars += uniqueVars.length;
+  }
+  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(join4(hubDir, ".env.example"), lines.join("\n") + "\n", "utf-8");
+  console.log(chalk3.green(`  Generated .env.example (${totalVars} vars)`));
 }
 function buildGitignoreLines(config) {
   const lines = [
@@ -1883,14 +2249,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);
@@ -1899,37 +2265,47 @@ 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 {

package/dist/{generate-BYB47MCP.js → generate-H4YM3WTV.js}

@@ -1,7 +1,7 @@
 import {
   generateCommand,
   generators
-} from "./chunk-VMSQC56H.js";
+} from "./chunk-NUJMJOEK.js";
 export {
   generateCommand,
   generators

package/dist/index.js

@@ -3,7 +3,7 @@ import {
   checkAndAutoRegenerate,
   generateCommand,
   loadHubConfig
-} from "./chunk-VMSQC56H.js";
+} from "./chunk-NUJMJOEK.js";
 
 // src/index.ts
 import { Command as Command19 } from "commander";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arvoretech/hub",
-  "version": "0.8.1",
+  "version": "0.9.0",
   "description": "CLI for managing AI-aware multi-repository workspaces",
   "main": "dist/index.js",
   "type": "module",