opencastle 0.5.1 → 0.7.0

package/src/cli/stack-config.ts

@@ -1,110 +1,43 @@
-import type { CmsChoice, DbChoice, PmChoice, NotifChoice, StackConfig, CopyDirOptions } from './types.js';
-
-// ── Skill / Technology labels ─────────────────────────────────
-
-/** Display name for each CMS choice */
-const CMS_LABELS: Record<Exclude<CmsChoice, 'none'>, { tech: string; skill: string }> = {
-  sanity: { tech: 'Sanity', skill: 'sanity-cms' },
-  contentful: { tech: 'Contentful', skill: 'contentful-cms' },
-  strapi: { tech: 'Strapi', skill: 'strapi-cms' },
-};
-
-/** Display name for each DB choice */
-const DB_LABELS: Record<Exclude<DbChoice, 'none'>, { tech: string; skill: string }> = {
-  supabase: { tech: 'Supabase', skill: 'supabase-database' },
-  convex: { tech: 'Convex', skill: 'convex-database' },
-};
-
-/** Display name for each PM choice */
-const PM_LABELS: Record<Exclude<PmChoice, 'none'>, { tech: string; skill: string }> = {
-  linear: { tech: 'Linear', skill: 'task-management' },
-  jira: { tech: 'Jira', skill: 'jira-management' },
-};
-
-/** Display name for each notifications choice */
-const NOTIF_LABELS: Record<Exclude<NotifChoice, 'none'>, { tech: string; skill: string }> = {
-  slack: { tech: 'Slack', skill: 'slack-notifications' },
-  teams: { tech: 'Teams', skill: 'teams-notifications' },
-};
-
-// ── Exclusion / inclusion maps ────────────────────────────────
-
-/** Skills to EXCLUDE based on CMS choice */
-const CMS_SKILL_MAP: Record<CmsChoice, string[]> = {
-  sanity: ['contentful-cms', 'strapi-cms'],
-  contentful: ['sanity-cms', 'strapi-cms'],
-  strapi: ['sanity-cms', 'contentful-cms'],
-  none: ['sanity-cms', 'contentful-cms', 'strapi-cms'],
-};
-
-/** Skills to EXCLUDE based on DB choice */
-const DB_SKILL_MAP: Record<DbChoice, string[]> = {
-  supabase: ['convex-database'],
-  convex: ['supabase-database'],
-  none: ['supabase-database', 'convex-database'],
-};
-
-/** Skills to EXCLUDE based on PM choice */
-const PM_SKILL_MAP: Record<PmChoice, string[]> = {
-  linear: ['jira-management'],
-  jira: ['task-management'],
-  none: ['task-management', 'jira-management'],
-};
-
-/** Agents to EXCLUDE based on CMS choice */
-const CMS_AGENT_EXCLUSIONS: Record<CmsChoice, string[]> = {
-  sanity: [],
-  contentful: [],
-  strapi: [],
-  none: ['content-engineer.agent.md'],
-};
+import type { TechTool, TeamTool, StackConfig, CopyDirOptions, RepoInfo } from './types.js';
+import {
+  PLUGINS,
+  TECH_PLUGINS,
+  TEAM_PLUGINS,
+  CMS_PLUGINS,
+  DB_PLUGINS,
+  ALL_PLUGIN_SKILL_NAMES,
+  getSelectedSkillNames,
+} from '../orchestrator/plugins/index.js';
+import type { PluginConfig } from '../orchestrator/plugins/types.js';
+
+// ── Tool registries (derived from plugins) ────────────────────
+
+interface ToolInfo {
+  tech: string;
+  skill: string | null;
+  mcpServer: string | null;
+}
 
-/** Agents to EXCLUDE based on DB choice */
-const DB_AGENT_EXCLUSIONS: Record<DbChoice, string[]> = {
-  supabase: [],
-  convex: [],
-  none: ['database-engineer.agent.md'],
-};
+/** All tech-tool metadata — derived from plugin configs. */
+const TECH_TOOL_INFO: Record<TechTool, ToolInfo> = Object.fromEntries(
+  TECH_PLUGINS.map((p) => [p.id, { tech: p.name, skill: p.skillName, mcpServer: p.mcpServerKey }])
+) as Record<TechTool, ToolInfo>;
 
-/** MCP server keys to INCLUDE based on CMS choice */
-const CMS_MCP_MAP: Record<CmsChoice, string[]> = {
-  sanity: ['Sanity'],
-  contentful: ['Contentful'],
-  strapi: ['Strapi'],
-  none: [],
-};
+/** All team-tool metadata — derived from plugin configs. */
+const TEAM_TOOL_INFO: Record<TeamTool, ToolInfo> = Object.fromEntries(
+  TEAM_PLUGINS.map((p) => [p.id, { tech: p.name, skill: p.skillName, mcpServer: p.mcpServerKey }])
+) as Record<TeamTool, ToolInfo>;
 
-/** MCP server keys to INCLUDE based on DB choice */
-const DB_MCP_MAP: Record<DbChoice, string[]> = {
-  supabase: ['Supabase'],
-  convex: ['Convex'],
-  none: [],
-};
+/** CMS-related tech tools. */
+const CMS_TOOLS: readonly TechTool[] = CMS_PLUGINS.map((p) => p.id) as TechTool[];
+/** Database-related tech tools. */
+const DB_TOOLS: readonly TechTool[] = DB_PLUGINS.map((p) => p.id) as TechTool[];
 
-/** MCP server keys to INCLUDE based on PM choice */
-const PM_MCP_MAP: Record<PmChoice, string[]> = {
-  linear: ['Linear'],
-  jira: ['Jira'],
-  none: [],
+/** MCP servers auto-included when detected in the repo. */
+const DETECTED_MCP_MAP: Record<string, string> = {
+  vercel: 'Vercel',
 };
 
-/** Skills to EXCLUDE based on notifications choice */
-const NOTIF_SKILL_MAP: Record<NotifChoice, string[]> = {
-  slack: ['teams-notifications'],
-  teams: ['slack-notifications'],
-  none: ['slack-notifications', 'teams-notifications'],
-};
-
-/** MCP server keys to INCLUDE based on notifications choice */
-const NOTIF_MCP_MAP: Record<NotifChoice, string[]> = {
-  slack: ['Slack'],
-  teams: ['Teams'],
-  none: [],
-};
-
-/** Always-included MCP servers */
-const CORE_MCP_SERVERS = ['chrome-devtools', 'Vercel'];
-
 // ── MCP environment variable requirements ─────────────────────
 
 export interface McpEnvRequirement {
@@ -118,49 +51,85 @@ export interface McpEnvRequirement {
 
 /**
  * Registry of MCP servers that require API keys via environment variables.
- * Only servers with `env` fields in mcp.json need to be listed here.
- * HTTP-based servers (Sanity, Slack, Vercel, etc.) handle auth via OAuth.
+ * Derived from plugin configs — only plugins with envVars are included.
  */
-const MCP_ENV_REQUIREMENTS: McpEnvRequirement[] = [
-  {
-    server: 'Linear',
-    envVar: 'LINEAR_API_KEY',
-    hint: 'Create at linear.app → Settings → API → Personal API keys',
-  },
-];
+const MCP_ENV_REQUIREMENTS: McpEnvRequirement[] = Object.values(PLUGINS)
+  .filter((p) => p.envVars.length > 0 && p.mcpServerKey)
+  .flatMap((p) =>
+    p.envVars.map((ev) => ({
+      server: p.mcpServerKey!,
+      envVar: ev.name,
+      hint: ev.hint,
+    }))
+  );
+
+// ── Exported helpers ──────────────────────────────────────────
 
+/**
+ * Skills to EXCLUDE — all tool-specific skills that are NOT selected.
+ */
 export function getExcludedSkills(stack: StackConfig): Set<string> {
-  return new Set([
-    ...CMS_SKILL_MAP[stack.cms],
-    ...DB_SKILL_MAP[stack.db],
-    ...PM_SKILL_MAP[stack.pm ?? 'none'],
-    ...NOTIF_SKILL_MAP[stack.notifications ?? 'none'],
-  ]);
+  const selectedIds = [...stack.techTools, ...stack.teamTools] as string[];
+  const includedSkills = new Set(getSelectedSkillNames(selectedIds));
+  return new Set(ALL_PLUGIN_SKILL_NAMES.filter((s) => !includedSkills.has(s)));
+}
+
+/**
+ * Plugin IDs to INCLUDE — the user's selected tools.
+ */
+export function getIncludedPluginIds(stack: StackConfig): Set<string> {
+  return new Set([...stack.techTools, ...stack.teamTools]);
 }
 
+/**
+ * Agents to EXCLUDE — content-engineer if no CMS, database-engineer if no DB.
+ */
 export function getExcludedAgents(stack: StackConfig): Set<string> {
-  return new Set([
-    ...CMS_AGENT_EXCLUSIONS[stack.cms],
-    ...DB_AGENT_EXCLUSIONS[stack.db],
-  ]);
+  const excluded = new Set<string>();
+  const hasCms = stack.techTools.some((t) => (CMS_TOOLS as readonly string[]).includes(t));
+  const hasDb = stack.techTools.some((t) => (DB_TOOLS as readonly string[]).includes(t));
+
+  if (!hasCms) excluded.add('content-engineer.agent.md');
+  if (!hasDb) excluded.add('database-engineer.agent.md');
+
+  return excluded;
 }
 
-export function getIncludedMcpServers(stack: StackConfig): Set<string> {
-  return new Set([
-    ...CORE_MCP_SERVERS,
-    ...CMS_MCP_MAP[stack.cms],
-    ...DB_MCP_MAP[stack.db],
-    ...PM_MCP_MAP[stack.pm ?? 'none'],
-    ...NOTIF_MCP_MAP[stack.notifications ?? 'none'],
-  ]);
+/**
+ * MCP servers to INCLUDE — core + selected tools + auto-detected from repo.
+ */
+export function getIncludedMcpServers(stack: StackConfig, repoInfo?: RepoInfo): Set<string> {
+  const servers = new Set<string>();
+
+  for (const tool of stack.techTools) {
+    const server = TECH_TOOL_INFO[tool]?.mcpServer;
+    if (server) servers.add(server);
+  }
+  for (const tool of stack.teamTools) {
+    const server = TEAM_TOOL_INFO[tool]?.mcpServer;
+    if (server) servers.add(server);
+  }
+
+  // Add servers for detected deployment targets
+  for (const dep of repoInfo?.deployment ?? []) {
+    const server = DETECTED_MCP_MAP[dep];
+    if (server) servers.add(server);
+  }
+
+  // Auto-detect NX from monorepo info
+  if (repoInfo?.monorepo === 'nx' && !stack.techTools.includes('nx')) {
+    servers.add('Nx');
+  }
+
+  return servers;
 }
 
 /**
  * Returns env var requirements for the MCP servers included in the stack.
  * Only returns entries for servers that actually need API keys.
  */
-export function getRequiredMcpEnvVars(stack: StackConfig): McpEnvRequirement[] {
-  const included = getIncludedMcpServers(stack);
+export function getRequiredMcpEnvVars(stack: StackConfig, repoInfo?: RepoInfo): McpEnvRequirement[] {
+  const included = getIncludedMcpServers(stack, repoInfo);
   return MCP_ENV_REQUIREMENTS.filter((req) => included.has(req.server));
 }
 
@@ -176,7 +145,6 @@ export function getCustomizationsTransform(
   stack: StackConfig
 ): NonNullable<CopyDirOptions['transform']> {
   return (content: string, srcPath: string) => {
-    // Pre-fill skill matrix with CMS and DB bindings
     if (srcPath.endsWith('skill-matrix.md')) {
       return transformSkillMatrix(content, stack);
     }
@@ -191,23 +159,97 @@ export function getCustomizationsTransform(
 function transformSkillMatrix(content: string, stack: StackConfig): string {
   let result = content;
 
-  // Fill the database row
-  if (stack.db !== 'none') {
-    const { tech, skill } = DB_LABELS[stack.db];
-    result = result.replace(
-      /(\| `database`\s*\|)\s*\|(\s*\|)/,
-      `$1 ${tech} | \`${skill}\` $2`
-    );
+  // Find first selected DB tool
+  const db = stack.techTools.find((t) => (DB_TOOLS as readonly string[]).includes(t));
+  if (db) {
+    const info = TECH_TOOL_INFO[db as TechTool];
+    if (info?.skill) {
+      result = result.replace(
+        /(\| `database`\s*\|)\s*\|(\s*\|)/,
+        `$1 ${info.tech} | \`${info.skill}\` $2`
+      );
+    }
   }
 
-  // Fill the CMS row
-  if (stack.cms !== 'none') {
-    const { tech, skill } = CMS_LABELS[stack.cms];
-    result = result.replace(
-      /(\| `cms`\s*\|)\s*\|(\s*\|)/,
-      `$1 ${tech} | \`${skill}\` $2`
-    );
+  // Find first selected CMS tool
+  const cms = stack.techTools.find((t) => (CMS_TOOLS as readonly string[]).includes(t));
+  if (cms) {
+    const info = TECH_TOOL_INFO[cms as TechTool];
+    if (info?.skill) {
+      result = result.replace(
+        /(\| `cms`\s*\|)\s*\|(\s*\|)/,
+        `$1 ${info.tech} | \`${info.skill}\` $2`
+      );
+    }
   }
 
   return result;
 }
+
+// ── Agent tool injection ──────────────────────────────────────
+
+/**
+ * Compute tool injections per agent based on the user's selected stack.
+ * Returns a Map where key = agent name (e.g. 'content-engineer'), value = tools to inject.
+ */
+export function getAgentToolInjections(stack: StackConfig): Map<string, string[]> {
+  const injections = new Map<string, string[]>();
+  const selectedIds = [...stack.techTools, ...stack.teamTools] as string[];
+
+  for (const id of selectedIds) {
+    const plugin = PLUGINS[id];
+    if (!plugin?.agentToolMap) continue;
+
+    for (const [agentName, tools] of Object.entries(plugin.agentToolMap)) {
+      const existing = injections.get(agentName) ?? [];
+      existing.push(...tools);
+      injections.set(agentName, existing);
+    }
+  }
+
+  return injections;
+}
+
+/**
+ * Returns a transform callback that injects plugin-specific tools
+ * into agent file frontmatter based on the user's stack selection.
+ */
+export function getAgentTransform(
+  stack: StackConfig
+): NonNullable<CopyDirOptions['transform']> {
+  const injections = getAgentToolInjections(stack);
+
+  return (content: string, srcPath: string) => {
+    // Extract agent name from filename (e.g., 'content-engineer' from 'content-engineer.agent.md')
+    const match = srcPath.match(/([^/\\]+)\.agent\.md$/);
+    if (!match) return content;
+
+    const agentName = match[1];
+    const toolsToInject = injections.get(agentName);
+    if (!toolsToInject || toolsToInject.length === 0) return content;
+
+    // Parse the frontmatter to find the tools array
+    const fmMatch = content.match(/^(---\n)([\s\S]*?)\n(---\n)([\s\S]*)$/);
+    if (!fmMatch) return content;
+
+    const frontmatter = fmMatch[2];
+    const body = fmMatch[4];
+
+    // Find and modify the tools line
+    const toolsMatch = frontmatter.match(/^(tools:\s*\[)(.*?)(\]\s*)$/m);
+    if (!toolsMatch) return content;
+
+    const existingTools = toolsMatch[2];
+    const injectedToolsList = toolsToInject.map((t) => `'${t}'`).join(', ');
+    const newTools = existingTools
+      ? `${existingTools}, ${injectedToolsList}`
+      : injectedToolsList;
+
+    const newFrontmatter = frontmatter.replace(
+      toolsMatch[0],
+      `${toolsMatch[1]}${newTools}${toolsMatch[3]}`
+    );
+
+    return `---\n${newFrontmatter}\n---\n${body}`;
+  };
+}

package/src/cli/types.ts

@@ -2,16 +2,36 @@ import type { ChildProcess } from 'node:child_process';
 
 // ── Stack selection types ──────────────────────────────────────
 
-export type CmsChoice = 'sanity' | 'contentful' | 'strapi' | 'none';
-export type DbChoice = 'supabase' | 'convex' | 'none';
-export type PmChoice = 'linear' | 'jira' | 'none';
-export type NotifChoice = 'slack' | 'teams' | 'none';
+export type IdeChoice = 'vscode' | 'cursor' | 'claude-code' | 'opencode';
+export type TechTool = 'sanity' | 'contentful' | 'strapi' | 'supabase' | 'convex' | 'vercel' | 'nx' | 'chrome-devtools';
+export type TeamTool = 'linear' | 'jira' | 'slack' | 'teams';
 
 export interface StackConfig {
-  cms: CmsChoice;
-  db: DbChoice;
-  pm: PmChoice;
-  notifications: NotifChoice;
+  ides: IdeChoice[];
+  techTools: TechTool[];
+  teamTools: TeamTool[];
+}
+
+/** Check if a stack config uses the legacy v1 format (individual choices with 'none'). */
+export function isLegacyStack(stack: unknown): stack is { cms: string; db: string; pm?: string; notifications?: string } {
+  return typeof stack === 'object' && stack !== null && 'cms' in stack;
+}
+
+/** Migrate a legacy v1 stack config to the v2 array format. */
+export function migrateStackConfig(
+  legacy: { cms: string; db: string; pm?: string; notifications?: string },
+  ide?: string
+): StackConfig {
+  const techTools: TechTool[] = [];
+  const teamTools: TeamTool[] = [];
+
+  if (legacy.cms && legacy.cms !== 'none') techTools.push(legacy.cms as TechTool);
+  if (legacy.db && legacy.db !== 'none') techTools.push(legacy.db as TechTool);
+  if (legacy.pm && legacy.pm !== 'none') teamTools.push(legacy.pm as TeamTool);
+  if (legacy.notifications && legacy.notifications !== 'none') teamTools.push(legacy.notifications as TeamTool);
+
+  const ides: IdeChoice[] = ide ? [ide as IdeChoice] : [];
+  return { ides, techTools, teamTools };
 }
 
 /** Context passed from bin/cli.mjs to every command handler. */
@@ -37,14 +57,35 @@ export interface CopyDirOptions {
   ) => Promise<string | null> | string | null;
 }
 
+/** Combined repository tooling info — auto-detected + user-declared. */
+export interface RepoInfo {
+  packageManager?: string;
+  monorepo?: string;
+  language?: string;
+  frameworks?: string[];
+  databases?: string[];
+  cms?: string[];
+  deployment?: string[];
+  testing?: string[];
+  cicd?: string[];
+  styling?: string[];
+  auth?: string[];
+  pm?: string[];
+  notifications?: string[];
+  mcpConfig?: boolean;
+  configFiles?: string[];
+}
+
 /** OpenCastle project manifest (.opencastle.json). */
 export interface Manifest {
   version: string;
   ide: string;
+  ides?: string[];
   installedAt: string;
   updatedAt: string;
   managedPaths?: ManagedPaths;
   stack?: StackConfig;
+  repoInfo?: RepoInfo;
 }
 
 /** Framework vs customizable file paths. */
@@ -55,7 +96,7 @@ export interface ManagedPaths {
 
 /** IDE adapter interface (init/update commands). */
 export interface IdeAdapter {
-  install(_pkgRoot: string, _projectRoot: string, _stack?: StackConfig): Promise<CopyResults>;
+  install(_pkgRoot: string, _projectRoot: string, _stack?: StackConfig, _repoInfo?: RepoInfo): Promise<CopyResults>;
   update(_pkgRoot: string, _projectRoot: string, _stack?: StackConfig): Promise<CopyResults>;
   getManagedPaths(): ManagedPaths;
 }
@@ -65,6 +106,8 @@ export interface SelectOption {
   label: string;
   hint?: string;
   value: string;
+  /** Whether this option starts selected (preselected). */
+  selected?: boolean;
 }
 
 /** Scaffold result from MCP config. */
@@ -73,6 +116,14 @@ export interface ScaffoldResult {
   action: 'created' | 'skipped';
 }
 
+/** IDE display labels. */
+export const IDE_LABELS: Record<IdeChoice, string> = {
+  vscode: 'VS Code',
+  cursor: 'Cursor',
+  'claude-code': 'Claude Code',
+  opencode: 'OpenCode',
+};
+
 // ── Run command types ──────────────────────────────────────────
 
 /** Validated task spec from YAML. */

package/src/cli/update.ts

@@ -1,18 +1,29 @@
 import { resolve } from 'node:path'
 import { readFile } from 'node:fs/promises'
 import { readManifest, writeManifest } from './manifest.js'
-import { confirm, closePrompts } from './prompt.js'
-import type { CliContext, IdeAdapter } from './types.js'
+import { confirm, closePrompts, c } from './prompt.js'
+import { isLegacyStack, migrateStackConfig } from './types.js'
+import type { CliContext, IdeAdapter, IdeChoice } from './types.js'
 
 const ADAPTERS: Record<string, () => Promise<IdeAdapter>> = {
   vscode: () => import('./adapters/vscode.js') as Promise<IdeAdapter>,
   cursor: () => import('./adapters/cursor.js') as Promise<IdeAdapter>,
   'claude-code': () =>
     import('./adapters/claude-code.js') as Promise<IdeAdapter>,
+  opencode: () =>
+    import('./adapters/opencode.js') as Promise<IdeAdapter>,
 }
 
 const VALID_IDES = Object.keys(ADAPTERS)
 
+/** IDE display labels */
+const IDE_DISPLAY: Record<IdeChoice, string> = {
+  vscode: 'VS Code',
+  cursor: 'Cursor',
+  'claude-code': 'Claude Code',
+  opencode: 'OpenCode',
+}
+
 export default async function update({
   pkgRoot,
   args,
@@ -22,18 +33,27 @@ export default async function update({
   const manifest = await readManifest(projectRoot)
   if (!manifest) {
     console.error(
-      '  ✗ No OpenCastle installation found. Run "npx opencastle init" first.'
+      `  ${c.red('✗')} No OpenCastle installation found. Run "npx opencastle init" first.`
     )
     process.exit(1)
   }
 
-  if (!manifest.ide || !VALID_IDES.includes(manifest.ide)) {
+  // Determine list of IDEs to update (support legacy single-IDE manifests)
+  const ides = manifest.ides?.length ? manifest.ides : [manifest.ide]
+  const invalidIdes = ides.filter((id) => !VALID_IDES.includes(id))
+  if (invalidIdes.length > 0) {
     console.error(
-      `  ✗ Invalid IDE "${manifest.ide}" in .opencastle.json. Valid options: ${VALID_IDES.join(', ')}`
+      `  ${c.red('✗')} Invalid IDE(s) "${invalidIdes.join(', ')}" in .opencastle.json. Valid: ${VALID_IDES.join(', ')}`
     )
     process.exit(1)
   }
 
+  // Migrate legacy stack config if needed
+  if (manifest.stack && isLegacyStack(manifest.stack)) {
+    manifest.stack = migrateStackConfig(manifest.stack, manifest.ide)
+    manifest.stack.ides = ides as IdeChoice[]
+  }
+
   const pkg = JSON.parse(
     await readFile(resolve(pkgRoot, 'package.json'), 'utf8')
   ) as { version: string }
@@ -45,23 +65,24 @@ export default async function update({
     return
   }
 
+  const ideNames = ides.map((id) => IDE_DISPLAY[id as IdeChoice] ?? id).join(', ')
   console.log(
-    `\n  🏰 OpenCastle ${dryRun ? 'dry-run' : 'update'}: v${manifest.version} → v${pkg.version}\n`
+    `\n  🏰 ${c.bold('OpenCastle')} ${dryRun ? 'dry-run' : 'update'}: ${c.dim(`v${manifest.version}`)} → ${c.green(`v${pkg.version}`)}\n`
   )
-  console.log(`  IDE: ${manifest.ide}`)
-  console.log('  Framework files will be overwritten.')
-  console.log('  Customization files will be preserved.\n')
+  console.log(`  IDEs: ${c.cyan(ideNames)}`)
+  console.log(`  ${c.dim('Framework files will be overwritten.')}`)
+  console.log(`  ${c.dim('Customization files will be preserved.')}\n`)
 
   if (dryRun) {
-    console.log('  [dry-run] Framework files that would be updated:\n')
+    console.log(`  ${c.dim('[dry-run]')} Framework files that would be updated:\n`)
     for (const p of manifest.managedPaths?.framework ?? []) {
-      console.log(`    ↻ ${p}`)
+      console.log(`    ${c.yellow('↻')} ${p}`)
     }
-    console.log('\n  Customization files that would be preserved:\n')
+    console.log(`\n  ${c.dim('[dry-run]')} Customization files that would be preserved:\n`)
     for (const p of manifest.managedPaths?.customizable ?? []) {
-      console.log(`    ✓ ${p}`)
+      console.log(`    ${c.green('✓')} ${p}`)
     }
-    console.log('\n  No files were written.\n')
+    console.log(`\n  ${c.dim('No files were written.')}\n`)
     return
   }
 
@@ -71,18 +92,55 @@ export default async function update({
     return
   }
 
-  const adapter = await ADAPTERS[manifest.ide]()
-  const results = await adapter.update(pkgRoot, projectRoot, manifest.stack)
+  // Update each IDE
+  let totalCopied = 0
+  let totalCreated = 0
+  const allManagedPaths = { framework: [] as string[], customizable: [] as string[] }
+
+  for (const ide of ides) {
+    const adapter = await ADAPTERS[ide]()
+    const results = await adapter.update(pkgRoot, projectRoot, manifest.stack)
+    totalCopied += results.copied.length
+    totalCreated += results.created.length
+
+    const managed = adapter.getManagedPaths()
+    allManagedPaths.framework.push(...managed.framework)
+    allManagedPaths.customizable.push(...managed.customizable)
+  }
+
+  // Refresh repo research on update
+  const { detectRepoInfo, mergeStackIntoRepoInfo } = await import('./detect.js')
+  const repoInfo = await detectRepoInfo(projectRoot)
 
   // Update manifest
   manifest.version = pkg.version
+  manifest.ides = ides
   manifest.updatedAt = new Date().toISOString()
-  manifest.managedPaths = adapter.getManagedPaths()
+  manifest.managedPaths = allManagedPaths
+  manifest.repoInfo = manifest.stack
+    ? mergeStackIntoRepoInfo(repoInfo, manifest.stack)
+    : repoInfo
   await writeManifest(projectRoot, manifest)
 
-  console.log(`\n  ✓ Updated ${results.copied.length} framework files`)
-  if (results.created.length > 0) {
-    console.log(`  + Created ${results.created.length} new files`)
+  console.log(`\n  ${c.green('✓')} Updated ${c.bold(String(totalCopied))} framework files`)
+  if (totalCreated > 0) {
+    console.log(`  ${c.green('+')} Created ${c.bold(String(totalCreated))} new files`)
+  }
+
+  // ── Reload window message ─────────────────────────────────────
+  const needsReload = ides.filter((id) => ['vscode', 'cursor'].includes(id))
+  if (needsReload.length > 0) {
+    console.log()
+    if (needsReload.includes('vscode')) {
+      console.log(
+        `  ${c.yellow('⟳')} Reload VS Code window (Cmd+Shift+P → "Developer: Reload Window") to pick up changes`
+      )
+    }
+    if (needsReload.includes('cursor')) {
+      console.log(
+        `  ${c.yellow('⟳')} Reload Cursor window to pick up the updated rule files`
+      )
+    }
   }
   console.log()