@arvoretech/hub 0.6.2 → 0.7.3

package/dist/{chunk-BLVKDXNY.js → chunk-2NWNZCYP.js}

@@ -43,6 +43,15 @@ async function getSavedEditor(hubDir) {
   const cache = await readCache(hubDir);
   return cache.editor;
 }
+async function getKiroMode(hubDir) {
+  const cache = await readCache(hubDir);
+  return cache.kiroMode;
+}
+async function saveKiroMode(hubDir, mode) {
+  const cache = await readCache(hubDir);
+  cache.kiroMode = mode;
+  await writeCache(hubDir, cache);
+}
 async function collectFileHashes(dir, extensions) {
   if (!existsSync(dir)) return [];
   const entries = await readdir(dir, { withFileTypes: true });
@@ -112,7 +121,7 @@ async function checkAndAutoRegenerate(hubDir) {
       return;
     }
     console.log(chalk.yellow("\n  Detected outdated configs, auto-regenerating..."));
-    const { generators: generators2 } = await import("./generate-G3ZOX55F.js");
+    const { generators: generators2 } = await import("./generate-BGTLIG4F.js");
     const generator = generators2[result.editor];
     if (!generator) {
       console.log(chalk.red(`  Unknown editor '${result.editor}' in cache. Run 'hub generate' manually.`));
@@ -129,33 +138,62 @@ async function checkAndAutoRegenerate(hubDir) {
 }
 
 // src/commands/generate.ts
+var HUB_DOCS_URL = "https://hub.arvore.com.br/llms-full.txt";
+function stripFrontMatter(content) {
+  const match = content.match(/^---\n[\s\S]*?\n---\n*/);
+  if (match) return content.slice(match[0].length);
+  return content;
+}
+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`));
+      return;
+    }
+    const content = await res.text();
+    const hubSkillDir = join3(skillsDir, "hub-docs");
+    await mkdir2(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.
+triggers: [hub, rhm, hub.yaml, generate, scan, setup, orchestrator, multi-repo, workspace]
+---
+
+${content}`;
+    await writeFile2(join3(hubSkillDir, "SKILL.md"), skillContent, "utf-8");
+    console.log(chalk2.green("  Fetched hub-docs skill from hub.arvore.com.br"));
+  } catch {
+    console.log(chalk2.yellow(`  Could not fetch hub docs, skipping hub-docs skill`));
+  }
+}
 var HUB_MARKER_START = "# >>> hub-managed (do not edit this section)";
 var HUB_MARKER_END = "# <<< hub-managed";
 var HOOK_EVENT_MAP = {
-  session_start: { cursor: "sessionStart", claude: "SessionStart", kiro: void 0 },
-  session_end: { cursor: "sessionEnd", claude: "SessionEnd", kiro: void 0 },
-  pre_tool_use: { cursor: "preToolUse", claude: "PreToolUse", kiro: "pre_tool_use" },
-  post_tool_use: { cursor: "postToolUse", claude: "PostToolUse", kiro: "post_tool_use" },
-  post_tool_use_failure: { cursor: void 0, claude: "PostToolUseFailure", kiro: void 0 },
-  stop: { cursor: "stop", claude: "Stop", kiro: "agent_stop" },
-  subagent_start: { cursor: "subagentStart", claude: "SubagentStart", kiro: void 0 },
-  subagent_stop: { cursor: "subagentStop", claude: "SubagentStop", kiro: void 0 },
-  pre_compact: { cursor: "preCompact", claude: "PreCompact", kiro: void 0 },
-  before_submit_prompt: { cursor: "beforeSubmitPrompt", claude: "UserPromptSubmit", kiro: "prompt_submit" },
-  before_shell_execution: { cursor: "beforeShellExecution", claude: void 0, kiro: void 0 },
-  after_shell_execution: { cursor: "afterShellExecution", claude: void 0, kiro: void 0 },
-  before_mcp_execution: { cursor: "beforeMCPExecution", claude: void 0, kiro: void 0 },
-  after_mcp_execution: { cursor: "afterMCPExecution", claude: void 0, kiro: void 0 },
-  after_file_edit: { cursor: "afterFileEdit", claude: void 0, kiro: "file_save" },
-  before_read_file: { cursor: "beforeReadFile", claude: void 0, kiro: void 0 },
-  before_tab_file_read: { cursor: "beforeTabFileRead", claude: void 0, kiro: void 0 },
-  after_tab_file_edit: { cursor: "afterTabFileEdit", claude: void 0, kiro: void 0 },
-  after_agent_response: { cursor: "afterAgentResponse", claude: void 0, kiro: void 0 },
-  after_agent_thought: { cursor: "afterAgentThought", claude: void 0, kiro: void 0 },
-  notification: { cursor: void 0, claude: "Notification", kiro: void 0 },
-  permission_request: { cursor: void 0, claude: "PermissionRequest", kiro: void 0 },
-  task_completed: { cursor: void 0, claude: "TaskCompleted", kiro: void 0 },
-  teammate_idle: { cursor: void 0, claude: "TeammateIdle", kiro: void 0 }
+  session_start: { cursor: "sessionStart", claude: "SessionStart", kiro: void 0, opencode: "session.created" },
+  session_end: { cursor: "sessionEnd", claude: "SessionEnd", kiro: void 0, opencode: "session.idle" },
+  pre_tool_use: { cursor: "preToolUse", claude: "PreToolUse", kiro: "pre_tool_use", opencode: "tool.execute.before" },
+  post_tool_use: { cursor: "postToolUse", claude: "PostToolUse", kiro: "post_tool_use", opencode: "tool.execute.after" },
+  post_tool_use_failure: { cursor: void 0, claude: "PostToolUseFailure", kiro: void 0, opencode: void 0 },
+  stop: { cursor: "stop", claude: "Stop", kiro: "agent_stop", opencode: "session.idle" },
+  subagent_start: { cursor: "subagentStart", claude: "SubagentStart", kiro: void 0, opencode: void 0 },
+  subagent_stop: { cursor: "subagentStop", claude: "SubagentStop", kiro: void 0, opencode: void 0 },
+  pre_compact: { cursor: "preCompact", claude: "PreCompact", kiro: void 0, opencode: "session.compacted" },
+  before_submit_prompt: { cursor: "beforeSubmitPrompt", claude: "UserPromptSubmit", kiro: "prompt_submit", opencode: void 0 },
+  before_shell_execution: { cursor: "beforeShellExecution", claude: void 0, kiro: void 0, opencode: "tool.execute.before" },
+  after_shell_execution: { cursor: "afterShellExecution", claude: void 0, kiro: void 0, opencode: "tool.execute.after" },
+  before_mcp_execution: { cursor: "beforeMCPExecution", claude: void 0, kiro: void 0, opencode: "tool.execute.before" },
+  after_mcp_execution: { cursor: "afterMCPExecution", claude: void 0, kiro: void 0, opencode: "tool.execute.after" },
+  after_file_edit: { cursor: "afterFileEdit", claude: void 0, kiro: "file_save", opencode: "file.edited" },
+  before_read_file: { cursor: "beforeReadFile", claude: void 0, kiro: void 0, opencode: void 0 },
+  before_tab_file_read: { cursor: "beforeTabFileRead", claude: void 0, kiro: void 0, opencode: void 0 },
+  after_tab_file_edit: { cursor: "afterTabFileEdit", claude: void 0, kiro: void 0, opencode: "file.edited" },
+  after_agent_response: { cursor: "afterAgentResponse", claude: void 0, kiro: void 0, opencode: void 0 },
+  after_agent_thought: { cursor: "afterAgentThought", claude: void 0, kiro: void 0, opencode: void 0 },
+  notification: { cursor: void 0, claude: "Notification", kiro: void 0, opencode: void 0 },
+  permission_request: { cursor: void 0, claude: "PermissionRequest", kiro: void 0, opencode: "permission.asked" },
+  task_completed: { cursor: void 0, claude: "TaskCompleted", kiro: void 0, opencode: "session.idle" },
+  teammate_idle: { cursor: void 0, claude: "TeammateIdle", kiro: void 0, opencode: void 0 }
 };
 function buildCursorHooks(hooks) {
   const cursorHooks = {};
@@ -197,8 +235,8 @@ function buildClaudeHooks(hooks) {
   if (Object.keys(claudeHooks).length === 0) return null;
   return claudeHooks;
 }
-async function generateCursorCommands(config, hubDir, cursorDir) {
-  const commandsDir = join3(cursorDir, "commands");
+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);
@@ -230,7 +268,7 @@ async function generateCursorCommands(config, hubDir, cursorDir) {
     }
   }
   if (count > 0) {
-    console.log(chalk2.green(`  Copied ${count} commands to .cursor/commands/`));
+    console.log(chalk2.green(`  Copied ${count} commands to ${editorName}`));
   }
 }
 async function writeManagedFile(filePath, managedLines) {
@@ -269,8 +307,14 @@ async function generateCursor(config, hubDir) {
   console.log(chalk2.green("  Generated .cursorignore"));
   if (config.mcps?.length) {
     const mcpConfig = {};
+    const upstreamSet = getUpstreamNames(config.mcps);
     for (const mcp of config.mcps) {
-      mcpConfig[mcp.name] = buildCursorMcpEntry(mcp);
+      if (upstreamSet.has(mcp.name)) continue;
+      if (mcp.upstreams?.length) {
+        mcpConfig[mcp.name] = buildProxyMcpEntry(mcp, config.mcps, buildCursorMcpEntry);
+      } else {
+        mcpConfig[mcp.name] = buildCursorMcpEntry(mcp);
+      }
     }
     await writeFile2(
       join3(cursorDir, "mcp.json"),
@@ -282,6 +326,27 @@ async function generateCursor(config, hubDir) {
   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");
+  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 content = stripFrontMatter(raw);
+      const mdcName = file.replace(/\.md$/, ".mdc");
+      const mdcContent = `---
+description: "${file.replace(/\.md$/, "")}"
+alwaysApply: true
+---
+
+${content}`;
+      await writeFile2(join3(cursorDir, "rules", mdcName), mdcContent, "utf-8");
+    }
+    if (mdFiles.length > 0) {
+      console.log(chalk2.green(`  Copied ${mdFiles.length} steering files to .cursor/rules/`));
+    }
+  } catch {
+  }
   const agentsDir = resolve(hubDir, "agents");
   try {
     const agentFiles = await readdir2(agentsDir);
@@ -315,6 +380,9 @@ async function generateCursor(config, hubDir) {
     }
   } catch {
   }
+  const cursorSkillsDirForDocs = join3(cursorDir, "skills");
+  await mkdir2(cursorSkillsDirForDocs, { recursive: true });
+  await fetchHubDocsSkill(cursorSkillsDirForDocs);
   if (config.hooks) {
     const cursorHooks = buildCursorHooks(config.hooks);
     if (cursorHooks) {
@@ -326,9 +394,65 @@ async function generateCursor(config, hubDir) {
       console.log(chalk2.green("  Generated .cursor/hooks.json"));
     }
   }
-  await generateCursorCommands(config, hubDir, cursorDir);
+  await generateEditorCommands(config, hubDir, cursorDir, ".cursor/commands/");
   await generateVSCodeSettings(config, hubDir);
 }
+function buildProxyUpstreams(proxyMcp, allMcps) {
+  const upstreamNames = new Set(proxyMcp.upstreams || []);
+  const upstreamEntries = [];
+  const collectedEnv = {};
+  for (const mcp of allMcps) {
+    if (!upstreamNames.has(mcp.name)) continue;
+    if (mcp.url || mcp.image) continue;
+    const entry = {
+      name: mcp.name,
+      command: "npx",
+      args: ["-y", mcp.package]
+    };
+    if (mcp.env) {
+      entry.env = {};
+      for (const [key, value] of Object.entries(mcp.env)) {
+        const envRef = value.match(/^\$\{(?:env:)?(\w+)\}$/);
+        if (envRef) {
+          entry.env[key] = `\${${envRef[1]}}`;
+          collectedEnv[envRef[1]] = value;
+        } else {
+          entry.env[key] = value;
+          collectedEnv[key] = value;
+        }
+      }
+    }
+    upstreamEntries.push(entry);
+  }
+  if (proxyMcp.env) {
+    for (const [key, value] of Object.entries(proxyMcp.env)) {
+      collectedEnv[key] = value;
+    }
+  }
+  return {
+    upstreamsJson: JSON.stringify(upstreamEntries),
+    collectedEnv
+  };
+}
+function buildProxyMcpEntry(proxyMcp, allMcps, buildEntry) {
+  const { upstreamsJson, collectedEnv } = buildProxyUpstreams(proxyMcp, allMcps);
+  const env = {
+    MCP_PROXY_UPSTREAMS: upstreamsJson,
+    ...collectedEnv
+  };
+  return buildEntry({ ...proxyMcp, env });
+}
+function getUpstreamNames(mcps) {
+  const names = /* @__PURE__ */ new Set();
+  for (const mcp of mcps) {
+    if (mcp.upstreams) {
+      for (const name of mcp.upstreams) {
+        names.add(name);
+      }
+    }
+  }
+  return names;
+}
 function buildCursorMcpEntry(mcp) {
   if (mcp.url) {
     return { url: mcp.url, ...mcp.env && { env: mcp.env } };
@@ -369,14 +493,22 @@ function buildClaudeCodeMcpEntry(mcp) {
     ...mcp.env && { env: mcp.env }
   };
 }
-function buildKiroMcpEntry(mcp) {
+function stripEnvPrefix(env) {
+  const result = {};
+  for (const [key, value] of Object.entries(env)) {
+    result[key] = value.replace(/\$\{env:(\w+)\}/g, "${$1}");
+  }
+  return result;
+}
+function buildKiroMcpEntry(mcp, mode = "editor") {
+  const env = mcp.env ? mode === "editor" ? stripEnvPrefix(mcp.env) : mcp.env : void 0;
   if (mcp.url) {
-    return { url: mcp.url, ...mcp.env && { env: mcp.env } };
+    return { url: mcp.url, ...env && { env } };
   }
   if (mcp.image) {
     const args = ["run", "-i", "--rm"];
-    if (mcp.env) {
-      for (const [key, value] of Object.entries(mcp.env)) {
+    if (env) {
+      for (const [key, value] of Object.entries(env)) {
         args.push("-e", `${key}=${value}`);
       }
     }
@@ -386,8 +518,380 @@ function buildKiroMcpEntry(mcp) {
   return {
     command: "npx",
     args: ["-y", mcp.package],
-    ...mcp.env && { env: mcp.env }
+    ...env && { env }
+  };
+}
+function buildKiroAgentContent(rawContent) {
+  const fmMatch = rawContent.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+  if (!fmMatch) {
+    return `---
+name: agent
+tools: ["@builtin"]
+---
+
+${rawContent}`;
+  }
+  const fmBlock = fmMatch[1];
+  const body = fmMatch[2];
+  const attrs = {};
+  for (const line of fmBlock.split("\n")) {
+    const match = line.match(/^(\w+):\s*(.+)$/);
+    if (match) attrs[match[1]] = match[2].trim();
+  }
+  const lines = ["---"];
+  if (attrs.name) lines.push(`name: ${attrs.name}`);
+  if (attrs.description) lines.push(`description: ${attrs.description}`);
+  if (attrs.tools) {
+    lines.push(`tools: ${attrs.tools}`);
+  } else {
+    lines.push(`tools: ["@builtin"]`);
+  }
+  if (attrs.model && attrs.model !== "inherit") {
+    lines.push(`model: ${attrs.model}`);
+  }
+  lines.push("---");
+  return `${lines.join("\n")}
+${body}`;
+}
+function buildOpenCodeMcpEntry(mcp) {
+  if (mcp.url) {
+    return { type: "remote", url: mcp.url };
+  }
+  if (mcp.image) {
+    const cmd = ["docker", "run", "-i", "--rm"];
+    if (mcp.env) {
+      for (const [key, value] of Object.entries(mcp.env)) {
+        cmd.push("-e", `${key}=${value}`);
+      }
+    }
+    cmd.push(mcp.image);
+    return { type: "local", command: cmd, ...mcp.env && { environment: mcp.env } };
+  }
+  return {
+    type: "local",
+    command: ["npx", "-y", mcp.package],
+    ...mcp.env && { environment: mcp.env }
+  };
+}
+function buildOpenCodeHooksPlugin(hooks) {
+  const handlers = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const [event, entries] of Object.entries(hooks)) {
+    const mapped = HOOK_EVENT_MAP[event]?.opencode;
+    if (!mapped || seen.has(mapped)) continue;
+    seen.add(mapped);
+    const commandEntries = entries.filter((e) => e.type === "command" && e.command);
+    if (commandEntries.length === 0) continue;
+    const cmds = commandEntries.map((e) => JSON.stringify(e.command));
+    handlers.push(`    "${mapped}": async (input, output) => {
+      for (const cmd of [${cmds.join(", ")}]) {
+        try { await $\`\${cmd}\`; } catch (e) { console.error("Hook failed:", cmd, e); }
+      }
+    }`);
+  }
+  if (handlers.length === 0) return null;
+  return `// Auto-generated by hub \u2014 maps hub.yaml hooks to OpenCode plugin events
+export const HubHooksPlugin = async ({ $ }) => {
+  return {
+${handlers.join(",\n")}
+  };
+};
+`;
+}
+function buildOpenCodeAgentMarkdown(name, content) {
+  const existingFrontmatter = content.match(/^---\n([\s\S]*?)\n---/);
+  let description = `Specialized agent for ${name} tasks`;
+  if (existingFrontmatter) {
+    const descMatch = existingFrontmatter[1].match(/^description:\s*["']?(.+?)["']?\s*$/m);
+    if (descMatch) description = descMatch[1];
+  }
+  const body = existingFrontmatter ? content.replace(/^---\n[\s\S]*?\n---\n*/, "") : content;
+  return `---
+description: "${description}"
+mode: subagent
+tools:
+  write: true
+  edit: true
+  bash: true
+---
+
+${body.trim()}
+`;
+}
+function buildOpenCodeOrchestratorRule(config) {
+  const taskFolder = config.workflow?.task_folder || "./tasks/<TASK_ID>/";
+  const steps = config.workflow?.pipeline || [];
+  const prompt = config.workflow?.prompt;
+  const enforce = config.workflow?.enforce_workflow ?? false;
+  const sections = [];
+  sections.push(`# Orchestrator
+
+## Your Main Responsibility
+
+You are an agent orchestrator. Your job is to ensure that any feature or task requested by the user is completed end-to-end using specialized sub-agents. Use \`@agent-name\` to invoke sub-agents for each phase of the pipeline.`);
+  if (enforce) {
+    sections.push(`
+## STRICT WORKFLOW ENFORCEMENT
+
+**YOU MUST FOLLOW THE PIPELINE DEFINED BELOW. NO EXCEPTIONS.**
+
+- NEVER skip a pipeline step, even if the task seems simple or obvious.
+- ALWAYS execute steps in the exact order defined. Do not reorder, merge, or parallelize steps unless the pipeline explicitly allows it.
+- ALWAYS call the designated sub-agent for each step. Do not attempt to perform a step yourself if an agent is assigned to it.
+- ALWAYS wait for a step to complete and validate its output before moving to the next step.
+- If a step produces a document, READ the document and confirm it is complete before proceeding.
+- If a step has unanswered questions or validation issues, RESOLVE them before advancing.
+- NEVER jump directly to coding without completing refinement first.
+- NEVER skip review or QA steps, even for small changes.
+- If the user asks you to skip a step, explain why the pipeline exists and ask for explicit confirmation before proceeding.`);
+  }
+  if (prompt?.prepend) {
+    sections.push(`
+${prompt.prepend.trim()}`);
+  }
+  if (config.integrations?.linear) {
+    const linear = config.integrations.linear;
+    sections.push(`
+## Task Management
+
+If the user doesn't have a task in their project management tool, create one using the Linear MCP.${linear.team ? ` Add it to the **${linear.team}** team.` : ""} Provide the link to the user so they can review and modify as needed.`);
+  }
+  sections.push(`
+## Repositories
+`);
+  for (const repo of config.repos) {
+    const parts = [`- **${repo.path}**`];
+    if (repo.description) parts.push(`\u2014 ${repo.description}`);
+    else if (repo.tech) parts.push(`\u2014 ${repo.tech}`);
+    if (repo.skills?.length) parts.push(`(skills: ${repo.skills.join(", ")})`);
+    sections.push(parts.join(" "));
+    if (repo.commands) {
+      const cmds = Object.entries(repo.commands).filter(([, v]) => v).map(([k, v]) => `\`${k}\`: \`${v}\``).join(", ");
+      if (cmds) sections.push(`  Commands: ${cmds}`);
+    }
+  }
+  if (prompt?.sections?.after_repositories) {
+    sections.push(`
+${prompt.sections.after_repositories.trim()}`);
+  }
+  const docStructure = buildDocumentStructure(steps, taskFolder);
+  sections.push(docStructure);
+  const pipelineSection = buildOpenCodePipelineSection(steps);
+  sections.push(pipelineSection);
+  if (prompt?.sections?.after_pipeline) {
+    sections.push(`
+${prompt.sections.after_pipeline.trim()}`);
+  }
+  if (config.integrations?.slack || config.integrations?.github) {
+    sections.push(buildDeliverySection(config));
+  }
+  if (prompt?.sections?.after_delivery) {
+    sections.push(`
+${prompt.sections.after_delivery.trim()}`);
+  }
+  if (config.memory) {
+    sections.push(`
+## Team Memory
+
+This workspace has a team memory knowledge base available via the \`team-memory\` MCP.
+
+**Before starting any task**, use \`search_memories\` to find relevant context \u2014 past decisions, conventions, known issues, and domain knowledge. This avoids repeating mistakes and ensures consistency with previous choices.
+
+**After completing a task**, if you discovered something valuable (a decision, a gotcha, a convention, domain insight), use \`add_memory\` to capture it for the team.
+
+Available tools: \`search_memories\`, \`get_memory\`, \`add_memory\`, \`list_memories\`, \`archive_memory\`, \`remove_memory\`.`);
+  }
+  sections.push(`
+## Troubleshooting and Debugging
+
+For bug reports or unexpected behavior, use the \`@debugger\` agent directly.
+It will:
+1. Collect context (symptoms, environment, timeline)
+2. Analyze logs and stack traces
+3. Form and test hypotheses systematically
+4. Identify the root cause
+5. Propose a solution or call coding agents to implement the fix`);
+  if (prompt?.sections) {
+    const reservedKeys = /* @__PURE__ */ new Set(["after_repositories", "after_pipeline", "after_delivery"]);
+    for (const [name, content] of Object.entries(prompt.sections)) {
+      if (reservedKeys.has(name)) continue;
+      const title = name.split(/[-_]/).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+      sections.push(`
+## ${title}
+
+${content.trim()}`);
+    }
+  }
+  if (prompt?.append) {
+    sections.push(`
+${prompt.append.trim()}`);
+  }
+  return sections.join("\n");
+}
+function buildOpenCodePipelineSection(steps) {
+  if (steps.length === 0) {
+    return `
+## Development Pipeline
+
+1. Use \`@refinement\` to collect requirements
+2. Use \`@coding-backend\` and/or \`@coding-frontend\` agents to implement
+3. Use \`@code-reviewer\` to review the implementation
+4. Use \`@qa-backend\` and/or \`@qa-frontend\` to test
+5. Create PRs and notify the team`;
+  }
+  const parts = [`
+## Development Pipeline
+`];
+  for (const step of steps) {
+    if (step.actions) {
+      parts.push(`### Delivery`);
+      parts.push(`After all validations pass, execute these actions:`);
+      for (const action of step.actions) {
+        parts.push(`- ${formatAction(action)}`);
+      }
+      continue;
+    }
+    const stepTitle = step.step.charAt(0).toUpperCase() + step.step.slice(1);
+    parts.push(`### ${stepTitle}`);
+    if (step.mode === "plan") {
+      parts.push(`**This step is a planning phase.** Switch to the Plan agent (Tab key) for collaborative planning with the user before any implementation begins.`);
+      parts.push(``);
+    }
+    if (step.agent) {
+      parts.push(`Call \`@${step.agent}\`.${step.output ? ` It writes to \`${step.output}\`.` : ""}`);
+      if (step.step === "refinement") {
+        parts.push(`
+After it runs, read the document and validate with the user:
+- If there are unanswered questions, ask the user one at a time
+- If the user requests adjustments, send back to the refinement agent
+- Do not proceed until the document is complete and approved by the user`);
+      }
+    }
+    if (Array.isArray(step.agents)) {
+      const agentList = step.agents.map((a) => {
+        if (typeof a === "string") return { agent: a };
+        return a;
+      });
+      if (step.parallel) {
+        parts.push(`Call these agents in parallel:`);
+      } else {
+        parts.push(`Call these agents in sequence:`);
+      }
+      for (const a of agentList) {
+        let line = `- \`@${a.agent}\``;
+        if (a.output) line += ` \u2192 writes to \`${a.output}\``;
+        if (a.when) line += ` (when: ${a.when})`;
+        parts.push(line);
+      }
+      if (step.step === "coding" || step.step === "code" || step.step === "implementation") {
+        parts.push(`
+If any coding agent has doubts, they will write questions in their document. Apply the same Q&A logic as refinement \u2014 validate with the user before proceeding.`);
+      }
+      if (step.step === "validation" || step.step === "review" || step.step === "qa") {
+        parts.push(`
+If any validation agent leaves comments requiring fixes, call the relevant coding agents again to address them.`);
+      }
+    }
+    if (step.mode === "plan") {
+      parts.push(`
+**After this step is complete and approved**, switch back to Build agent to proceed with the next step.`);
+    }
+    parts.push("");
+  }
+  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 gitignoreLines = buildGitignoreLines(config);
+  await writeManagedFile(join3(hubDir, ".gitignore"), gitignoreLines);
+  console.log(chalk2.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");
+  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");
+    }
+    if (mdFiles.length > 0) {
+      console.log(chalk2.green(`  Copied ${mdFiles.length} steering files to .opencode/rules/`));
+    }
+  } catch {
+  }
+  const opencodeConfig = {
+    $schema: "https://opencode.ai/config.json"
   };
+  if (config.mcps?.length) {
+    const mcpConfig = {};
+    const upstreamSet = getUpstreamNames(config.mcps);
+    for (const mcp of config.mcps) {
+      if (upstreamSet.has(mcp.name)) continue;
+      if (mcp.upstreams?.length) {
+        mcpConfig[mcp.name] = buildProxyMcpEntry(mcp, config.mcps, buildOpenCodeMcpEntry);
+      } else {
+        mcpConfig[mcp.name] = buildOpenCodeMcpEntry(mcp);
+      }
+    }
+    opencodeConfig.mcp = mcpConfig;
+  }
+  opencodeConfig.instructions = [".opencode/rules/*.md"];
+  await writeFile2(
+    join3(hubDir, "opencode.json"),
+    JSON.stringify(opencodeConfig, null, 2) + "\n",
+    "utf-8"
+  );
+  console.log(chalk2.green("  Generated opencode.json"));
+  const agentsDir = resolve(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 agentName = file.replace(/\.md$/, "");
+      const converted = buildOpenCodeAgentMarkdown(agentName, content);
+      await writeFile2(join3(opencodeDir, "agents", file), converted, "utf-8");
+    }
+    console.log(chalk2.green(`  Copied ${mdFiles.length} agents to .opencode/agents/`));
+  } catch {
+    console.log(chalk2.yellow("  No agents/ directory found, skipping agent copy"));
+  }
+  const skillsDir = resolve(hubDir, "skills");
+  try {
+    const skillFolders = await readdir2(skillsDir);
+    let count = 0;
+    for (const folder of skillFolders) {
+      const skillFile = join3(skillsDir, folder, "SKILL.md");
+      try {
+        await readFile3(skillFile);
+        await cp(join3(skillsDir, folder), join3(opencodeDir, "skills", folder), { recursive: true });
+        count++;
+      } catch {
+      }
+    }
+    if (count > 0) {
+      console.log(chalk2.green(`  Copied ${count} skills to .opencode/skills/`));
+    }
+  } catch {
+  }
+  await fetchHubDocsSkill(join3(opencodeDir, "skills"));
+  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 generateVSCodeSettings(config, hubDir);
 }
 function buildKiroSteeringContent(content, inclusion = "always", meta) {
   const frontMatter = ["---", `inclusion: ${inclusion}`];
@@ -408,9 +912,9 @@ function buildKiroOrchestratorRule(config) {
 
 ## Your Main Responsibility
 
-You are the development orchestrator. Your job is to ensure that any feature or task requested by the user is completed end-to-end by following a structured pipeline. You work as a single agent but follow specialized instructions from steering files for each phase of development.
+You are the development orchestrator. Your job is to ensure that any feature or task requested by the user is completed end-to-end by following a structured pipeline. You delegate specialized work to subagents defined in \`.kiro/agents/\`.
 
-> **Note:** This workspace uses steering files in \`.kiro/steering/\` to provide role-specific instructions for each pipeline step. When a step says "follow the instructions from steering file X", read that file and apply its guidelines to the current task.`);
+> **Note:** This workspace has custom subagents in \`.kiro/agents/\`. Each pipeline step delegates to the appropriate subagent. Use \`/agent-name\` or instruct Kiro to "use the X subagent" to invoke them.`);
   if (enforce) {
     sections.push(`
 ## STRICT WORKFLOW ENFORCEMENT
@@ -419,7 +923,7 @@ You are the development orchestrator. Your job is to ensure that any feature or
 
 - NEVER skip a pipeline step, even if the task seems simple or obvious.
 - ALWAYS execute steps in the exact order defined. Do not reorder, merge, or parallelize steps unless the pipeline explicitly allows it.
-- ALWAYS follow the designated steering file for each step. Do not improvise if a steering file is assigned.
+- ALWAYS use the designated subagent for each step. Do not improvise if a subagent is assigned.
 - ALWAYS wait for a step to complete and validate its output before moving to the next step.
 - If a step produces a document, READ the document and confirm it is complete before proceeding.
 - If a step has unanswered questions or validation issues, RESOLVE them before advancing.
@@ -514,18 +1018,18 @@ function buildKiroPipelineSection(steps) {
     return `
 ## Development Pipeline
 
-Since Kiro does not support sub-agents, follow each step sequentially, applying the guidelines from the corresponding steering file:
+Follow each step sequentially, delegating to the appropriate subagent:
 
-1. **Refinement** \u2014 Read and follow \`agent-refinement.md\` steering file to collect requirements. Write output to the task document.
-2. **Coding** \u2014 Follow the coding steering files (\`agent-coding-backend.md\`, \`agent-coding-frontend.md\`) to implement the feature.
-3. **Review** \u2014 Follow \`agent-code-reviewer.md\` to review the implementation.
-4. **QA** \u2014 Follow \`agent-qa-backend.md\` and/or \`agent-qa-frontend.md\` to test.
+1. **Refinement** \u2014 Use the \`refinement\` subagent to collect requirements. Write output to the task document.
+2. **Coding** \u2014 Use the \`coding-backend\` and \`coding-frontend\` subagents to implement the feature.
+3. **Review** \u2014 Use the \`code-reviewer\` subagent to review the implementation.
+4. **QA** \u2014 Use the \`qa-backend\` and/or \`qa-frontend\` subagents to test.
 5. **Delivery** \u2014 Create PRs and notify the team.`;
   }
   const parts = [`
 ## Development Pipeline
 
-Follow each step sequentially, applying the role-specific instructions from the corresponding steering file at each phase.
+Follow each step sequentially, delegating to the appropriate subagent at each phase.
 `];
   for (const step of steps) {
     if (step.actions) {
@@ -543,7 +1047,7 @@ Follow each step sequentially, applying the role-specific instructions from the
       parts.push(``);
     }
     if (step.agent) {
-      parts.push(`Follow the instructions from the \`agent-${step.agent}.md\` steering file.${step.output ? ` Write output to \`${step.output}\`.` : ""}`);
+      parts.push(`Use the \`${step.agent}\` subagent.${step.output ? ` Write output to \`${step.output}\`.` : ""}`);
       if (step.step === "refinement") {
         parts.push(`
 After completing the refinement, validate with the user:
@@ -557,9 +1061,9 @@ After completing the refinement, validate with the user:
         if (typeof a === "string") return { agent: a };
         return a;
       });
-      parts.push(`Follow the instructions from these steering files sequentially:`);
+      parts.push(`Use these subagents sequentially:`);
       for (const a of agentList) {
-        let line = `- \`agent-${a.agent}.md\``;
+        let line = `- \`${a.agent}\``;
         if (a.output) line += ` \u2192 write to \`${a.output}\``;
         if (a.when) line += ` (when: ${a.when})`;
         parts.push(line);
@@ -801,8 +1305,9 @@ function buildDeliverySection(config) {
 `];
   if (config.integrations?.github) {
     const gh = config.integrations.github;
+    const tool = gh.pr_tool === "mcp" ? "GitHub MCP" : "GitHub CLI";
     parts.push(`### Pull Requests`);
-    parts.push(`For each repository with changes, push the branch and create a PR using the GitHub MCP.`);
+    parts.push(`For each repository with changes, push the branch and create a PR using the ${tool}.`);
     if (gh.pr_branch_pattern) {
       parts.push(`Branch naming pattern: \`${gh.pr_branch_pattern}\``);
     }
@@ -882,12 +1387,37 @@ async function generateClaudeCode(config, hubDir) {
     }
   } catch {
   }
-  await writeFile2(join3(hubDir, "CLAUDE.md"), claudeMdSections.join("\n"), "utf-8");
+  const claudeSkillsDirForDocs = join3(claudeDir, "skills");
+  await mkdir2(claudeSkillsDirForDocs, { recursive: true });
+  await fetchHubDocsSkill(claudeSkillsDirForDocs);
+  const hubSteeringDirClaude = resolve(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 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`));
+    }
+  } catch {
+  }
+  await writeFile2(join3(hubDir, "CLAUDE.md"), claudeMdSections.join("\n\n"), "utf-8");
   console.log(chalk2.green("  Generated CLAUDE.md"));
   if (config.mcps?.length) {
     const mcpJson = {};
+    const upstreamSet = getUpstreamNames(config.mcps);
     for (const mcp of config.mcps) {
-      mcpJson[mcp.name] = buildClaudeCodeMcpEntry(mcp);
+      if (upstreamSet.has(mcp.name)) continue;
+      if (mcp.upstreams?.length) {
+        mcpJson[mcp.name] = buildProxyMcpEntry(mcp, config.mcps, buildClaudeCodeMcpEntry);
+      } else {
+        mcpJson[mcp.name] = buildClaudeCodeMcpEntry(mcp);
+      }
     }
     await writeFile2(
       join3(hubDir, ".mcp.json"),
@@ -948,6 +1478,25 @@ async function generateKiro(config, hubDir) {
   const settingsDir = join3(kiroDir, "settings");
   await mkdir2(steeringDir, { recursive: true });
   await mkdir2(settingsDir, { recursive: true });
+  let mode = await getKiroMode(hubDir);
+  if (!mode) {
+    const { kiroMode } = await inquirer.prompt([
+      {
+        type: "list",
+        name: "kiroMode",
+        message: "How do you use Kiro?",
+        choices: [
+          { name: "Editor / IDE (e.g. Kiro IDE, VS Code)", value: "editor" },
+          { name: "CLI (e.g. kiro-cli)", value: "cli" }
+        ]
+      }
+    ]);
+    mode = kiroMode;
+    await saveKiroMode(hubDir, mode);
+    console.log(chalk2.dim(`  Saved Kiro mode: ${mode}`));
+  } else {
+    console.log(chalk2.dim(`  Using saved Kiro mode: ${mode}`));
+  }
   const gitignoreLines = buildGitignoreLines(config);
   await writeManagedFile(join3(hubDir, ".gitignore"), gitignoreLines);
   console.log(chalk2.green("  Generated .gitignore"));
@@ -957,21 +1506,33 @@ async function generateKiro(config, hubDir) {
   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");
+  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 content = stripFrontMatter(raw);
+      const kiroSteering = buildKiroSteeringContent(content);
+      await writeFile2(join3(steeringDir, file), kiroSteering, "utf-8");
+    }
+    if (mdFiles.length > 0) {
+      console.log(chalk2.green(`  Copied ${mdFiles.length} steering files to .kiro/steering/`));
+    }
+  } catch {
+  }
   const agentsDir = resolve(hubDir, "agents");
   try {
+    const kiroAgentsDir = join3(kiroDir, "agents");
+    await mkdir2(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 agentName = file.replace(/\.md$/, "");
-      const steeringContent = buildKiroSteeringContent(agentContent, "auto", {
-        name: agentName,
-        description: `Role-specific instructions for the ${agentName} phase. Include when working on ${agentName}-related tasks.`
-      });
-      const steeringName = `agent-${file}`;
-      await writeFile2(join3(steeringDir, steeringName), steeringContent, "utf-8");
+      const kiroAgent = buildKiroAgentContent(agentContent);
+      await writeFile2(join3(kiroAgentsDir, file), kiroAgent, "utf-8");
     }
-    console.log(chalk2.green(`  Copied ${mdFiles.length} agents as steering files`));
+    console.log(chalk2.green(`  Copied ${mdFiles.length} agents to .kiro/agents/`));
   } catch {
     console.log(chalk2.yellow("  No agents/ directory found, skipping agent copy"));
   }
@@ -997,10 +1558,20 @@ async function generateKiro(config, hubDir) {
     }
   } catch {
   }
+  const kiroSkillsDirForDocs = join3(kiroDir, "skills");
+  await mkdir2(kiroSkillsDirForDocs, { recursive: true });
+  await fetchHubDocsSkill(kiroSkillsDirForDocs);
   if (config.mcps?.length) {
     const mcpConfig = {};
+    const upstreamSet = getUpstreamNames(config.mcps);
+    const buildEntry = (mcp) => buildKiroMcpEntry(mcp, mode);
     for (const mcp of config.mcps) {
-      mcpConfig[mcp.name] = buildKiroMcpEntry(mcp);
+      if (upstreamSet.has(mcp.name)) continue;
+      if (mcp.upstreams?.length) {
+        mcpConfig[mcp.name] = buildProxyMcpEntry(mcp, config.mcps, buildEntry);
+      } else {
+        mcpConfig[mcp.name] = buildKiroMcpEntry(mcp, mode);
+      }
     }
     await writeFile2(
       join3(settingsDir, "mcp.json"),
@@ -1049,6 +1620,59 @@ async function generateVSCodeSettings(config, hubDir) {
   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)"));
+  const workspaceFile = `${config.name}.code-workspace`;
+  const workspacePath = join3(hubDir, workspaceFile);
+  let existingWorkspace = {};
+  if (existsSync2(workspacePath)) {
+    try {
+      const raw = await readFile3(workspacePath, "utf-8");
+      existingWorkspace = JSON.parse(raw);
+    } catch {
+      existingWorkspace = {};
+    }
+  } else {
+    const files = await readdir2(hubDir);
+    const existing2 = files.find((f) => f.endsWith(".code-workspace"));
+    if (existing2) {
+      try {
+        const raw = await readFile3(join3(hubDir, existing2), "utf-8");
+        existingWorkspace = JSON.parse(raw);
+      } catch {
+        existingWorkspace = {};
+      }
+    }
+  }
+  const TECH_LABELS = {
+    nestjs: "NestJS",
+    nextjs: "Next.js",
+    react: "React",
+    elixir: "Elixir",
+    phoenix: "Phoenix",
+    django: "Django",
+    fastapi: "FastAPI",
+    rails: "Rails",
+    spring: "Spring",
+    go: "Go",
+    vue: "Vue",
+    svelte: "Svelte",
+    angular: "Angular",
+    express: "Express",
+    koa: "Koa"
+  };
+  const folders = [
+    { path: ".", name: "Root" }
+  ];
+  for (const repo of config.repos) {
+    const repoPath = repo.path.replace(/^\.\//, "");
+    const displayName = repo.display_name || (repo.tech ? `${repo.name} (${TECH_LABELS[repo.tech] || repo.tech})` : repo.name);
+    folders.push({ path: repoPath, name: displayName });
+  }
+  const workspace = {
+    folders,
+    settings: existingWorkspace.settings || {}
+  };
+  await writeFile2(workspacePath, JSON.stringify(workspace, null, "	") + "\n", "utf-8");
+  console.log(chalk2.green(`  Generated ${workspaceFile}`));
 }
 function buildGitignoreLines(config) {
   const lines = [
@@ -1092,7 +1716,8 @@ function buildGitignoreLines(config) {
 var generators = {
   cursor: { name: "Cursor", generate: generateCursor },
   "claude-code": { name: "Claude Code", generate: generateClaudeCode },
-  kiro: { name: "Kiro", generate: generateKiro }
+  kiro: { name: "Kiro", generate: generateKiro },
+  opencode: { name: "OpenCode", generate: generateOpenCode }
 };
 async function resolveEditor(opts) {
   const hubDir = process.cwd();
@@ -1108,6 +1733,9 @@ async function resolveEditor(opts) {
         }))
       }
     ]);
+    const cache = await readCache(hubDir);
+    delete cache.kiroMode;
+    await writeCache(hubDir, cache);
     return editor2;
   }
   if (opts.editor) return opts.editor;
@@ -1126,7 +1754,7 @@ async function resolveEditor(opts) {
   ]);
   return editor;
 }
-var generateCommand = new Command("generate").description("Generate editor-specific configuration files from hub.yaml").option("-e, --editor <editor>", "Target editor (cursor, claude-code, kiro)").option("--reset-editor", "Reset saved editor preference and choose again").action(async (opts) => {
+var generateCommand = new Command("generate").description("Generate editor-specific configuration files from hub.yaml").option("-e, --editor <editor>", "Target editor (cursor, claude-code, kiro, opencode)").option("--reset-editor", "Reset saved editor preference and choose again").action(async (opts) => {
   const hubDir = process.cwd();
   const config = await loadHubConfig(hubDir);
   if (config.memory) {

package/dist/{generate-G3ZOX55F.js → generate-BGTLIG4F.js}

@@ -1,7 +1,7 @@
 import {
   generateCommand,
   generators
-} from "./chunk-BLVKDXNY.js";
+} from "./chunk-2NWNZCYP.js";
 export {
   generateCommand,
   generators

package/dist/index.js

@@ -3,10 +3,10 @@ import {
   checkAndAutoRegenerate,
   generateCommand,
   loadHubConfig
-} from "./chunk-BLVKDXNY.js";
+} from "./chunk-2NWNZCYP.js";
 
 // src/index.ts
-import { Command as Command18 } from "commander";
+import { Command as Command19 } from "commander";
 
 // src/commands/init.ts
 import { Command } from "commander";
@@ -2852,11 +2852,327 @@ var directoryCommand = new Command17("directory").alias("dir").description("Brow
   console.log(chalk17.dim("    hub commands add <owner>/<repo>\n"));
 });
 
+// src/commands/scan.ts
+import { Command as Command18 } from "commander";
+import { existsSync as existsSync14 } from "fs";
+import { readdir as readdir6, readFile as readFile8, cp as cp4, mkdir as mkdir9, writeFile as writeFile11 } from "fs/promises";
+import { execSync as execSync13 } from "child_process";
+import { join as join17 } from "path";
+import { parse as parse2 } from "yaml";
+import chalk18 from "chalk";
+import inquirer from "inquirer";
+var EDITOR_DIRS = [".kiro", ".cursor", ".opencode", ".claude"];
+async function findUnregisteredRepos(hubDir, config) {
+  const registeredPaths = new Set(
+    config.repos.map((r) => r.path.replace(/^\.\//, ""))
+  );
+  const entries = await readdir6(hubDir);
+  const unregistered = [];
+  for (const entry of entries) {
+    if (registeredPaths.has(entry)) continue;
+    const gitDir = join17(hubDir, entry, ".git");
+    if (existsSync14(gitDir)) {
+      unregistered.push(entry);
+    }
+  }
+  return unregistered;
+}
+function detectTech(repoDir) {
+  if (existsSync14(join17(repoDir, "mix.exs"))) return "elixir";
+  if (existsSync14(join17(repoDir, "next.config.js")) || existsSync14(join17(repoDir, "next.config.ts")) || existsSync14(join17(repoDir, "next.config.mjs"))) return "nextjs";
+  if (existsSync14(join17(repoDir, "nest-cli.json"))) return "nestjs";
+  if (existsSync14(join17(repoDir, "angular.json"))) return "angular";
+  if (existsSync14(join17(repoDir, "svelte.config.js"))) return "svelte";
+  if (existsSync14(join17(repoDir, "nuxt.config.ts")) || existsSync14(join17(repoDir, "nuxt.config.js"))) return "vue";
+  if (existsSync14(join17(repoDir, "go.mod"))) return "go";
+  if (existsSync14(join17(repoDir, "Gemfile"))) return "rails";
+  if (existsSync14(join17(repoDir, "manage.py"))) return "django";
+  if (existsSync14(join17(repoDir, "package.json"))) return "react";
+  return void 0;
+}
+function getGitRemote(repoDir) {
+  try {
+    return execSync13("git remote get-url origin", { cwd: repoDir, encoding: "utf-8" }).trim();
+  } catch {
+    return "";
+  }
+}
+function buildRepoYaml(repo) {
+  const lines = [];
+  lines.push(`  - name: ${repo.name}`);
+  lines.push(`    path: ${repo.path}`);
+  lines.push(`    url: ${repo.url}`);
+  if (repo.tech) lines.push(`    tech: ${repo.tech}`);
+  return lines.join("\n");
+}
+function findReposInsertionPoint(content) {
+  const lines = content.split("\n");
+  let lastRepoLine = -1;
+  let inRepos = false;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (/^repos:/.test(line)) {
+      inRepos = true;
+      continue;
+    }
+    if (inRepos) {
+      if (/^[a-z]/.test(line) || /^[A-Z]/.test(line)) break;
+      if (line.trim() !== "") lastRepoLine = i;
+    }
+  }
+  if (lastRepoLine === -1) return content.length;
+  let offset = 0;
+  for (let i = 0; i <= lastRepoLine; i++) {
+    offset += lines[i].length + 1;
+  }
+  return offset;
+}
+async function findUnsyncedAssets(hubDir) {
+  const unsynced = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const editor of EDITOR_DIRS) {
+    const editorSkillsDir = join17(hubDir, editor, "skills");
+    if (!existsSync14(editorSkillsDir)) continue;
+    try {
+      const folders = await readdir6(editorSkillsDir);
+      for (const folder of folders) {
+        if (folder === "hub-docs") continue;
+        const skillFile = join17(editorSkillsDir, folder, "SKILL.md");
+        if (!existsSync14(skillFile)) continue;
+        const canonicalSkillFile = join17(hubDir, "skills", folder, "SKILL.md");
+        if (existsSync14(canonicalSkillFile)) continue;
+        const key = `skill:${folder}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        unsynced.push({ type: "skill", name: folder, source: editor });
+      }
+    } catch {
+    }
+  }
+  for (const editor of EDITOR_DIRS) {
+    const editorAgentsDir = join17(hubDir, editor, "agents");
+    if (!existsSync14(editorAgentsDir)) continue;
+    try {
+      const files = await readdir6(editorAgentsDir);
+      for (const file of files) {
+        if (!file.endsWith(".md")) continue;
+        const canonicalFile = join17(hubDir, "agents", file);
+        if (existsSync14(canonicalFile)) continue;
+        const key = `agent:${file}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        unsynced.push({ type: "agent", name: file, source: editor });
+      }
+    } catch {
+    }
+  }
+  const steeringDir = join17(hubDir, ".kiro", "steering");
+  if (existsSync14(steeringDir)) {
+    const canonicalSteeringDir = join17(hubDir, "steering");
+    try {
+      const files = await readdir6(steeringDir);
+      for (const file of files) {
+        if (!file.endsWith(".md")) continue;
+        if (file === "orchestrator.md") continue;
+        const canonicalFile = join17(canonicalSteeringDir, file);
+        if (existsSync14(canonicalFile)) continue;
+        const key = `steering:${file}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        unsynced.push({ type: "steering", name: file, source: ".kiro" });
+      }
+    } catch {
+    }
+  }
+  const cursorRulesDir = join17(hubDir, ".cursor", "rules");
+  if (existsSync14(cursorRulesDir)) {
+    const canonicalSteeringDir = join17(hubDir, "steering");
+    try {
+      const files = await readdir6(cursorRulesDir);
+      for (const file of files) {
+        if (!file.endsWith(".mdc")) continue;
+        if (file === "orchestrator.mdc") continue;
+        const mdName = file.replace(/\.mdc$/, ".md");
+        const canonicalFile = join17(canonicalSteeringDir, mdName);
+        if (existsSync14(canonicalFile)) continue;
+        const key = `steering:${mdName}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        unsynced.push({ type: "steering", name: mdName, source: ".cursor" });
+      }
+    } catch {
+    }
+  }
+  const opencodeRulesDir = join17(hubDir, ".opencode", "rules");
+  if (existsSync14(opencodeRulesDir)) {
+    const canonicalSteeringDir = join17(hubDir, "steering");
+    try {
+      const files = await readdir6(opencodeRulesDir);
+      for (const file of files) {
+        if (!file.endsWith(".md")) continue;
+        if (file === "orchestrator.md") continue;
+        const canonicalFile = join17(canonicalSteeringDir, file);
+        if (existsSync14(canonicalFile)) continue;
+        const key = `steering:${file}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        unsynced.push({ type: "steering", name: file, source: ".opencode" });
+      }
+    } catch {
+    }
+  }
+  return unsynced;
+}
+function stripFrontMatter(content) {
+  const match = content.match(/^---\n[\s\S]*?\n---\n*/);
+  if (match) return content.slice(match[0].length);
+  return content;
+}
+async function syncAssets(hubDir, assets) {
+  for (const asset of assets) {
+    if (asset.type === "skill") {
+      const src = join17(hubDir, asset.source, "skills", asset.name);
+      const dest = join17(hubDir, "skills", asset.name);
+      await mkdir9(join17(hubDir, "skills"), { recursive: true });
+      await cp4(src, dest, { recursive: true });
+      const skillMd = join17(dest, "SKILL.md");
+      if (existsSync14(skillMd)) {
+        const raw = await readFile8(skillMd, "utf-8");
+        const cleaned = stripFrontMatter(raw);
+        if (cleaned !== raw) {
+          await writeFile11(skillMd, cleaned, "utf-8");
+        }
+      }
+      console.log(chalk18.green(`  Synced skill: ${asset.name} (from ${asset.source})`));
+    } else if (asset.type === "agent") {
+      const src = join17(hubDir, asset.source, "agents", asset.name);
+      const dest = join17(hubDir, "agents", asset.name);
+      await mkdir9(join17(hubDir, "agents"), { recursive: true });
+      const raw = await readFile8(src, "utf-8");
+      const cleaned = stripFrontMatter(raw);
+      await writeFile11(dest, cleaned, "utf-8");
+      console.log(chalk18.green(`  Synced agent: ${asset.name} (from ${asset.source})`));
+    } else if (asset.type === "steering") {
+      const dest = join17(hubDir, "steering", asset.name);
+      await mkdir9(join17(hubDir, "steering"), { recursive: true });
+      let raw;
+      if (asset.source === ".cursor") {
+        const mdcName = asset.name.replace(/\.md$/, ".mdc");
+        raw = await readFile8(join17(hubDir, ".cursor", "rules", mdcName), "utf-8");
+      } else if (asset.source === ".opencode") {
+        raw = await readFile8(join17(hubDir, ".opencode", "rules", asset.name), "utf-8");
+      } else {
+        raw = await readFile8(join17(hubDir, asset.source, "steering", asset.name), "utf-8");
+      }
+      const cleaned = stripFrontMatter(raw);
+      await writeFile11(dest, cleaned, "utf-8");
+      console.log(chalk18.green(`  Synced steering: ${asset.name} (from ${asset.source})`));
+    }
+  }
+}
+var scanCommand = new Command18("scan").description("Detect git repositories not registered in hub.yaml").option("-y, --yes", "Auto-add all found repos without prompting").action(async (opts) => {
+  const hubDir = process.cwd();
+  const configPath = join17(hubDir, "hub.yaml");
+  if (!existsSync14(configPath)) {
+    console.log(chalk18.red("No hub.yaml found in current directory."));
+    process.exit(1);
+  }
+  const content = await readFile8(configPath, "utf-8");
+  const config = parse2(content);
+  let hasChanges = false;
+  console.log(chalk18.blue("\nScanning for unregistered repositories...\n"));
+  const unregistered = await findUnregisteredRepos(hubDir, config);
+  if (unregistered.length === 0) {
+    console.log(chalk18.green("All repositories are registered in hub.yaml."));
+  } else {
+    console.log(chalk18.yellow(`Found ${unregistered.length} unregistered repo(s):
+`));
+    const repoDetails = unregistered.map((name) => {
+      const repoDir = join17(hubDir, name);
+      const tech = detectTech(repoDir);
+      const url = getGitRemote(repoDir);
+      return { name, tech, url, path: `./${name}` };
+    });
+    for (const repo of repoDetails) {
+      const techLabel = repo.tech ? chalk18.dim(` (${repo.tech})`) : "";
+      console.log(`  ${chalk18.cyan(repo.name)}${techLabel}`);
+    }
+    console.log();
+    let toAdd = repoDetails;
+    if (!opts.yes) {
+      const { selected } = await inquirer.prompt([
+        {
+          type: "checkbox",
+          name: "selected",
+          message: "Select repos to add to hub.yaml:",
+          choices: repoDetails.map((r) => ({
+            name: `${r.name}${r.tech ? ` (${r.tech})` : ""}`,
+            value: r.name,
+            checked: true
+          }))
+        }
+      ]);
+      toAdd = repoDetails.filter((r) => selected.includes(r.name));
+    }
+    if (toAdd.length > 0) {
+      const originalContent = await readFile8(configPath, "utf-8");
+      const insertAt = findReposInsertionPoint(originalContent);
+      const before = originalContent.slice(0, insertAt);
+      const after = originalContent.slice(insertAt);
+      const newEntries = toAdd.map(buildRepoYaml).join("\n");
+      const updatedContent = before + newEntries + "\n" + after;
+      await import("fs/promises").then((fs) => fs.writeFile(configPath, updatedContent, "utf-8"));
+      console.log(chalk18.green(`Added ${toAdd.length} repo(s) to hub.yaml.`));
+      hasChanges = true;
+    }
+  }
+  console.log(chalk18.blue("\nScanning for unsynced skills, agents, and steering...\n"));
+  const unsyncedAssets = await findUnsyncedAssets(hubDir);
+  if (unsyncedAssets.length === 0) {
+    console.log(chalk18.green("All assets are synced."));
+  } else {
+    console.log(chalk18.yellow(`Found ${unsyncedAssets.length} unsynced asset(s):
+`));
+    for (const asset of unsyncedAssets) {
+      console.log(`  ${chalk18.cyan(asset.name)} ${chalk18.dim(`(${asset.type} from ${asset.source})`)}`);
+    }
+    console.log();
+    let toSync = unsyncedAssets;
+    if (!opts.yes) {
+      const { selected } = await inquirer.prompt([
+        {
+          type: "checkbox",
+          name: "selected",
+          message: "Select assets to sync to canonical folders:",
+          choices: unsyncedAssets.map((a) => ({
+            name: `${a.name} (${a.type} from ${a.source})`,
+            value: `${a.type}:${a.name}`,
+            checked: true
+          }))
+        }
+      ]);
+      toSync = unsyncedAssets.filter((a) => selected.includes(`${a.type}:${a.name}`));
+    }
+    if (toSync.length > 0) {
+      await syncAssets(hubDir, toSync);
+      console.log(chalk18.green(`Synced ${toSync.length} asset(s).`));
+      hasChanges = true;
+    }
+  }
+  if (hasChanges) {
+    console.log(chalk18.cyan(`
+Run ${chalk18.bold("hub generate")} to update editor configs.
+`));
+  } else {
+    console.log();
+  }
+});
+
 // src/index.ts
-var program = new Command18();
+var program = new Command19();
 program.name("hub").description(
   "Give your AI coding assistant the full picture. Multi-repo context, agent orchestration, and end-to-end workflows."
-).version("0.6.2").enablePositionalOptions();
+).version("0.7.3").enablePositionalOptions();
 program.addCommand(initCommand);
 program.addCommand(addRepoCommand);
 program.addCommand(setupCommand);
@@ -2877,4 +3193,5 @@ program.addCommand(toolsCommand);
 program.addCommand(memoryCommand);
 program.addCommand(updateCommand);
 program.addCommand(directoryCommand);
+program.addCommand(scanCommand);
 program.parse();

package/package.json

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