opencastle 0.19.0 → 0.21.0

package/src/cli/adapters/vscode.ts

@@ -3,8 +3,8 @@ import { mkdir, readFile, writeFile, copyFile } from 'node:fs/promises'
 import { existsSync } from 'node:fs'
 import { copyDir, getOrchestratorRoot, removeDirIfExists, getPluginsRoot, getPluginSkillEntries } from '../copy.js'
 import { scaffoldMcpConfig } from '../mcp.js'
-import { getExcludedSkills, getExcludedAgents, getCustomizationsTransform, getIncludedPluginIds, getAgentTransform } from '../stack-config.js'
-import type { CopyResults, CopyDirOptions, ManagedPaths, RepoInfo, StackConfig } from '../types.js'
+import { getExcludedSkills, getExcludedAgents, getIncludedPluginIds, getAgentTransform } from '../stack-config.js'
+import type { CopyResults, CopyDirOptions, DoctorCheck, ManagedPaths, RepoInfo, StackConfig } from '../types.js'
 
 /**
  * VS Code / GitHub Copilot adapter.
@@ -17,7 +17,7 @@ import type { CopyResults, CopyDirOptions, ManagedPaths, RepoInfo, StackConfig }
  *   skills/                    → .github/skills/
  *   agent-workflows/           → .github/agent-workflows/
  *   prompts/                   → .github/prompts/
- *   customizations/            → .github/customizations/  (scaffolded once)
+ *   customizations/            → .opencastle/  (scaffolded once)
  */
 
 export const IDE_ID = 'vscode'
@@ -33,7 +33,7 @@ const FRAMEWORK_DIRS = [
 ]
 
 /** Directories scaffolded once and never overwritten. */
-const CUSTOMIZABLE_DIRS = ['customizations']
+const CUSTOMIZABLE_DIRS: string[] = []
 
 export async function install(
   pkgRoot: string,
@@ -99,18 +99,6 @@ export async function install(
     }
   }
 
-  // Customization templates (scaffold once)
-  const custTransform = stack ? getCustomizationsTransform(stack) : undefined
-  for (const dir of CUSTOMIZABLE_DIRS) {
-    const srcDir = resolve(srcRoot, dir)
-    if (!existsSync(srcDir)) continue
-    const destDir = resolve(destRoot, dir)
-    const sub = await copyDir(srcDir, destDir, { transform: custTransform })
-    results.copied.push(...sub.copied)
-    results.skipped.push(...sub.skipped)
-    results.created.push(...sub.created)
-  }
-
   // MCP server config → .vscode/mcp.json (scaffold once)
   const mcpResult = await scaffoldMcpConfig(
     projectRoot,
@@ -195,8 +183,19 @@ export function getManagedPaths(): ManagedPaths {
       ...FRAMEWORK_DIRS.map((d) => `.github/${d}/`),
     ],
     customizable: [
-      ...CUSTOMIZABLE_DIRS.map((d) => `.github/${d}/`),
+      '.opencastle/',
       '.vscode/mcp.json',
     ],
   }
 }
+
+export function getDoctorChecks(): DoctorCheck[] {
+  return [
+    { label: 'Copilot instructions', path: '.github/copilot-instructions.md', type: 'file' },
+    { label: 'Instruction files', path: '.github/instructions/', type: 'dir', countContents: true, countFilter: '.md' },
+    { label: 'Agent definitions', path: '.github/agents/', type: 'dir', countContents: true, countFilter: '.agent.md' },
+    { label: 'Skills directory', path: '.github/skills/', type: 'dir', countContents: true },
+    { label: 'Agent workflows', path: '.github/agent-workflows/', type: 'dir', countContents: true },
+    { label: 'Prompts directory', path: '.github/prompts/', type: 'dir', countContents: true },
+  ]
+}

package/src/cli/dashboard.ts

@@ -260,7 +260,7 @@ export default async function dashboard({
         '  \u{1F4C2} Showing demo data (use without --seed to read project logs)'
       )
     } else if (hasLogs) {
-      console.log('  \u{1F4C2} Reading logs from .github/customizations/logs/')
+      console.log('  \u{1F4C2} Reading logs from .opencastle/logs/')
     } else {
       console.log(
         '  \u{1F4A1} No agent logs found. Run agents with OpenCastle to generate data, or use --seed for demo data.'

package/src/cli/doctor.test.ts

@@ -0,0 +1,245 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+import { mkdtempSync, realpathSync } from 'node:fs'
+import { mkdirSync, writeFileSync, rmSync } from 'node:fs'
+import { join } from 'node:path'
+import { tmpdir } from 'node:os'
+import { runDoctorCheck, checkMcpFromPaths } from './doctor.js'
+import { IDE_ADAPTERS } from './adapters/index.js'
+import type { DoctorCheck } from './types.js'
+
+// ── Test helper ───────────────────────────────────────────────
+
+function makeTempDir(): string {
+  return realpathSync(mkdtempSync(join(tmpdir(), 'doctor-test-')))
+}
+
+// ── runDoctorCheck ────────────────────────────────────────────
+
+describe('runDoctorCheck — file checks', () => {
+  let tmpDir: string
+
+  beforeEach(() => {
+    tmpDir = makeTempDir()
+  })
+
+  afterEach(() => {
+    rmSync(tmpDir, { recursive: true, force: true })
+  })
+
+  it('passes when file exists', async () => {
+    writeFileSync(join(tmpDir, 'CLAUDE.md'), '# Instructions')
+    const check: DoctorCheck = { label: 'Root file', path: 'CLAUDE.md', type: 'file' }
+    const result = await runDoctorCheck(tmpDir, check)
+    expect(result.ok).toBe(true)
+    expect(result.label).toBe('Root file')
+  })
+
+  it('fails when file does not exist', async () => {
+    const check: DoctorCheck = { label: 'Root file', path: 'CLAUDE.md', type: 'file' }
+    const result = await runDoctorCheck(tmpDir, check)
+    expect(result.ok).toBe(false)
+    expect(result.detail).toContain('CLAUDE.md not found')
+  })
+
+  it('passes for nested path when file exists', async () => {
+    mkdirSync(join(tmpDir, '.github'), { recursive: true })
+    writeFileSync(join(tmpDir, '.github', 'copilot-instructions.md'), '# Instructions')
+    const check: DoctorCheck = { label: 'Copilot instructions', path: '.github/copilot-instructions.md', type: 'file' }
+    const result = await runDoctorCheck(tmpDir, check)
+    expect(result.ok).toBe(true)
+  })
+})
+
+describe('runDoctorCheck — dir checks', () => {
+  let tmpDir: string
+
+  beforeEach(() => {
+    tmpDir = makeTempDir()
+  })
+
+  afterEach(() => {
+    rmSync(tmpDir, { recursive: true, force: true })
+  })
+
+  it('fails when directory does not exist', async () => {
+    const check: DoctorCheck = { label: 'Skills', path: '.claude/skills/', type: 'dir' }
+    const result = await runDoctorCheck(tmpDir, check)
+    expect(result.ok).toBe(false)
+    expect(result.detail).toContain('.claude/skills/ not found')
+  })
+
+  it('passes when directory exists (no countContents)', async () => {
+    mkdirSync(join(tmpDir, '.claude', 'skills'), { recursive: true })
+    const check: DoctorCheck = { label: 'Skills', path: '.claude/skills/', type: 'dir' }
+    const result = await runDoctorCheck(tmpDir, check)
+    expect(result.ok).toBe(true)
+  })
+
+  it('fails when dir exists but no files match countFilter', async () => {
+    mkdirSync(join(tmpDir, '.github', 'agents'), { recursive: true })
+    writeFileSync(join(tmpDir, '.github', 'agents', 'notes.txt'), 'not an agent')
+    const check: DoctorCheck = {
+      label: 'Agent definitions',
+      path: '.github/agents/',
+      type: 'dir',
+      countContents: true,
+      countFilter: '.agent.md',
+    }
+    const result = await runDoctorCheck(tmpDir, check)
+    expect(result.ok).toBe(false)
+    expect(result.detail).toContain('No files found')
+  })
+
+  it('passes and reports count when files match countFilter', async () => {
+    mkdirSync(join(tmpDir, '.github', 'agents'), { recursive: true })
+    writeFileSync(join(tmpDir, '.github', 'agents', 'developer.agent.md'), '# Developer')
+    writeFileSync(join(tmpDir, '.github', 'agents', 'reviewer.agent.md'), '# Reviewer')
+    const check: DoctorCheck = {
+      label: 'Agent definitions',
+      path: '.github/agents/',
+      type: 'dir',
+      countContents: true,
+      countFilter: '.agent.md',
+    }
+    const result = await runDoctorCheck(tmpDir, check)
+    expect(result.ok).toBe(true)
+    expect(result.detail).toBe('2 file(s)')
+  })
+
+  it('counts all files when no countFilter specified', async () => {
+    mkdirSync(join(tmpDir, '.claude', 'skills'), { recursive: true })
+    writeFileSync(join(tmpDir, '.claude', 'skills', 'git-workflow.md'), '# Skill')
+    writeFileSync(join(tmpDir, '.claude', 'skills', 'testing.md'), '# Skill')
+    writeFileSync(join(tmpDir, '.claude', 'skills', 'unused.txt'), 'other')
+    const check: DoctorCheck = {
+      label: 'Skills',
+      path: '.claude/skills/',
+      type: 'dir',
+      countContents: true,
+    }
+    const result = await runDoctorCheck(tmpDir, check)
+    expect(result.ok).toBe(true)
+    expect(result.detail).toBe('3 file(s)')
+  })
+
+  it('fails when directory exists but is empty (countContents)', async () => {
+    mkdirSync(join(tmpDir, '.github', 'instructions'), { recursive: true })
+    const check: DoctorCheck = {
+      label: 'Instruction files',
+      path: '.github/instructions/',
+      type: 'dir',
+      countContents: true,
+      countFilter: '.md',
+    }
+    const result = await runDoctorCheck(tmpDir, check)
+    expect(result.ok).toBe(false)
+    expect(result.detail).toContain('No files found')
+  })
+})
+
+// ── checkMcpFromPaths ─────────────────────────────────────────
+
+describe('checkMcpFromPaths', () => {
+  let tmpDir: string
+
+  beforeEach(() => {
+    tmpDir = makeTempDir()
+  })
+
+  afterEach(() => {
+    rmSync(tmpDir, { recursive: true, force: true })
+  })
+
+  it('returns ok when mcp config exists', () => {
+    mkdirSync(join(tmpDir, '.vscode'), { recursive: true })
+    writeFileSync(join(tmpDir, '.vscode', 'mcp.json'), '{}')
+    const result = checkMcpFromPaths(tmpDir, ['.vscode/mcp.json'])
+    expect(result.ok).toBe(true)
+    expect(result.warning).toBeFalsy()
+  })
+
+  it('returns warning when mcp config does not exist', () => {
+    const result = checkMcpFromPaths(tmpDir, ['.vscode/mcp.json'])
+    expect(result.ok).toBe(true)
+    expect(result.warning).toBe(true)
+    expect(result.detail).toContain('MCP tools unavailable')
+  })
+
+  it('returns ok with no warning when paths is empty', () => {
+    const result = checkMcpFromPaths(tmpDir, [])
+    expect(result.ok).toBe(true)
+    expect(result.warning).toBeFalsy()
+  })
+})
+
+// ── adapter getDoctorChecks ───────────────────────────────────
+
+describe('vscode adapter getDoctorChecks', () => {
+  it('returns expected checks', async () => {
+    const adapter = await IDE_ADAPTERS['vscode']()
+    const checks = adapter.getDoctorChecks()
+    expect(checks.length).toBeGreaterThan(0)
+    expect(checks.find((c) => c.path === '.github/copilot-instructions.md')?.type).toBe('file')
+    expect(checks.find((c) => c.path === '.github/agents/')?.countFilter).toBe('.agent.md')
+    expect(checks.find((c) => c.path === '.github/instructions/')?.countFilter).toBe('.md')
+    expect(checks.find((c) => c.path === '.github/skills/')).toBeDefined()
+  })
+})
+
+describe('cursor adapter getDoctorChecks', () => {
+  it('returns expected checks', async () => {
+    const adapter = await IDE_ADAPTERS['cursor']()
+    const checks = adapter.getDoctorChecks()
+    expect(checks.length).toBeGreaterThan(0)
+    expect(checks.find((c) => c.path === '.cursorrules')?.type).toBe('file')
+    expect(checks.find((c) => c.path === '.cursor/rules/agents/')?.countFilter).toBe('.mdc')
+    expect(checks.find((c) => c.path === '.cursor/rules/skills/')?.countFilter).toBe('.mdc')
+  })
+})
+
+describe('claude-code adapter getDoctorChecks', () => {
+  it('returns expected checks', async () => {
+    const adapter = await IDE_ADAPTERS['claude-code']()
+    const checks = adapter.getDoctorChecks()
+    expect(checks.length).toBeGreaterThan(0)
+    expect(checks.find((c) => c.path === 'CLAUDE.md')?.type).toBe('file')
+    expect(checks.find((c) => c.path === '.claude/agents/')).toBeDefined()
+    expect(checks.find((c) => c.path === '.claude/skills/')).toBeDefined()
+    // claude-code: prompts and workflows share 'commands' dir
+    expect(checks.find((c) => c.path === '.claude/commands/')).toBeDefined()
+    expect(checks.find((c) => c.label === 'Commands directory')).toBeDefined()
+  })
+})
+
+describe('opencode adapter getDoctorChecks', () => {
+  it('returns expected checks', async () => {
+    const adapter = await IDE_ADAPTERS['opencode']()
+    const checks = adapter.getDoctorChecks()
+    expect(checks.length).toBeGreaterThan(0)
+    expect(checks.find((c) => c.path === 'AGENTS.md')?.type).toBe('file')
+    expect(checks.find((c) => c.path === '.opencode/agents/')).toBeDefined()
+    expect(checks.find((c) => c.path === '.opencode/skills/')).toBeDefined()
+    // opencode: separate prompts and workflows dirs
+    expect(checks.find((c) => c.path === '.opencode/prompts/')).toBeDefined()
+    expect(checks.find((c) => c.path === '.opencode/workflows/')).toBeDefined()
+  })
+})
+
+describe('all adapters satisfy getDoctorChecks interface', () => {
+  const ideIds = ['vscode', 'cursor', 'claude-code', 'opencode']
+
+  for (const ide of ideIds) {
+    it(`${ide}: every check has label, path, and type`, async () => {
+      const adapter = await IDE_ADAPTERS[ide]()
+      const checks = adapter.getDoctorChecks()
+      expect(Array.isArray(checks)).toBe(true)
+      for (const c of checks) {
+        expect(typeof c.label).toBe('string')
+        expect(c.label.length).toBeGreaterThan(0)
+        expect(typeof c.path).toBe('string')
+        expect(c.path.length).toBeGreaterThan(0)
+        expect(['file', 'dir']).toContain(c.type)
+      }
+    })
+  }
+})

package/src/cli/doctor.ts

@@ -1,9 +1,11 @@
 import { resolve } from 'node:path';
-import { readFile, access, readdir, writeFile } from 'node:fs/promises';
+import { readdir, writeFile } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
 import { readManifest } from './manifest.js';
 import { getRequiredMcpEnvVars } from './stack-config.js';
-import type { CliContext, Manifest, IdeChoice } from './types.js';
+import { IDE_ADAPTERS } from './adapters/index.js';
+import type { CliContext, DoctorCheck, IdeChoice, Manifest } from './types.js';
+import { IDE_LABELS } from './types.js';
 
 // ── Styled output helpers ─────────────────────────────────────
 
@@ -24,25 +26,26 @@ interface CheckResult {
 
 function checkManifest(manifest: Manifest | null): CheckResult {
   if (!manifest) {
-    return { ok: false, label: 'OpenCastle manifest (.opencastle.json)', detail: 'Not found. Run "npx opencastle init" first.' };
+    return { ok: false, label: 'OpenCastle manifest (.opencastle/manifest.json)', detail: 'Not found. Run "npx opencastle init" first.' };
   }
-  return { ok: true, label: 'OpenCastle manifest (.opencastle.json)', detail: `v${manifest.version}, IDE: ${manifest.ides?.join(', ') ?? manifest.ide}` };
+  return { ok: true, label: 'OpenCastle manifest (.opencastle/manifest.json)', detail: `v${manifest.version}, IDE: ${manifest.ides?.join(', ') ?? manifest.ide}` };
 }
 
 async function checkCustomizations(projectRoot: string): Promise<CheckResult> {
-  const dir = resolve(projectRoot, '.github', 'customizations');
+  const dir = resolve(projectRoot, '.opencastle');
   if (!existsSync(dir)) {
-    return { ok: false, label: 'Customizations directory', detail: '.github/customizations/ not found' };
+    return { ok: false, label: 'Customizations directory', detail: '.opencastle/ not found' };
   }
   const files = await readdir(dir).catch(() => []);
   return { ok: true, label: 'Customizations directory', detail: `${files.length} entries` };
 }
 
 async function checkSkillMatrix(projectRoot: string): Promise<CheckResult> {
-  const path = resolve(projectRoot, '.github', 'customizations', 'agents', 'skill-matrix.json');
+  const path = resolve(projectRoot, '.opencastle', 'agents', 'skill-matrix.json');
   if (!existsSync(path)) {
-    return { ok: false, label: 'Skill matrix', detail: 'File not found at .github/customizations/agents/skill-matrix.json' };
+    return { ok: false, label: 'Skill matrix', detail: 'File not found at .opencastle/agents/skill-matrix.json' };
   }
+  const { readFile } = await import('node:fs/promises');
   const content = await readFile(path, 'utf8');
   try {
     const data = JSON.parse(content);
@@ -59,50 +62,14 @@ async function checkSkillMatrix(projectRoot: string): Promise<CheckResult> {
   }
 }
 
-async function checkInstructions(projectRoot: string): Promise<CheckResult> {
-  const dir = resolve(projectRoot, '.github', 'instructions');
-  if (!existsSync(dir)) {
-    return { ok: false, label: 'Instruction files', detail: '.github/instructions/ not found' };
-  }
-  const files = await readdir(dir).catch(() => []);
-  const mdFiles = files.filter((f) => f.endsWith('.md'));
-  if (mdFiles.length === 0) {
-    return { ok: false, label: 'Instruction files', detail: 'No .md files in .github/instructions/' };
-  }
-  return { ok: true, label: 'Instruction files', detail: `${mdFiles.length} instruction files` };
-}
-
-async function checkAgents(projectRoot: string): Promise<CheckResult> {
-  const dir = resolve(projectRoot, '.github', 'agents');
-  if (!existsSync(dir)) {
-    return { ok: false, label: 'Agent definitions', detail: '.github/agents/ directory not found' };
-  }
-  const files = await readdir(dir).catch(() => []);
-  const agentFiles = files.filter((f) => f.endsWith('.agent.md'));
-  if (agentFiles.length === 0) {
-    return { ok: false, label: 'Agent definitions', detail: 'No .agent.md files found' };
-  }
-  return { ok: true, label: 'Agent definitions', detail: `${agentFiles.length} agents` };
-}
-
-async function checkSkills(projectRoot: string): Promise<CheckResult> {
-  const dir = resolve(projectRoot, '.github', 'skills');
-  if (!existsSync(dir)) {
-    return { ok: false, label: 'Skills directory', detail: '.github/skills/ not found' };
-  }
-  const entries = await readdir(dir).catch(() => []);
-  return { ok: true, label: 'Skills directory', detail: `${entries.length} skills` };
-}
-
 async function checkLogs(projectRoot: string): Promise<CheckResult> {
-  const dir = resolve(projectRoot, '.github', 'customizations', 'logs');
+  const dir = resolve(projectRoot, '.opencastle', 'logs');
   if (!existsSync(dir)) {
     return { ok: false, label: 'Observability logs', detail: 'logs/ directory not found — dashboard will be empty' };
   }
   const required = ['sessions.ndjson', 'delegations.ndjson', 'reviews.ndjson', 'panels.ndjson', 'disputes.ndjson'];
   const missing = required.filter((f) => !existsSync(resolve(dir, f)));
   if (missing.length > 0) {
-    // Auto-create missing log files — they're empty NDJSON stubs
     for (const file of missing) {
       await writeFile(resolve(dir, file), '', { flag: 'wx' }).catch(() => {/* already exists */});
     }
@@ -141,62 +108,51 @@ async function checkDotEnv(projectRoot: string, manifest: Manifest | null): Prom
   return { ok: true, label: '.env file', detail: 'Present' };
 }
 
-async function checkIdeConfigs(projectRoot: string, manifest: Manifest | null): Promise<CheckResult> {
-  if (!manifest) {
-    return { ok: false, label: 'IDE configuration files', detail: 'No manifest — cannot check' };
-  }
-  const ides = manifest.ides ?? [manifest.ide];
-  const checks: Array<{ ide: string; file: string; found: boolean }> = [];
-
-  for (const ide of ides) {
-    let configFile: string;
-    switch (ide as IdeChoice) {
-      case 'vscode':
-        configFile = '.github/copilot-instructions.md';
-        break;
-      case 'cursor':
-        configFile = '.cursor/rules/opencastle.mdc';
-        break;
-      case 'claude-code':
-        configFile = '.claude/settings.json';
-        break;
-      case 'opencode':
-        configFile = '.opencode/agents.md';
-        break;
-      default:
-        continue;
+// ── Generic adapter-driven checks ────────────────────────────────
+
+/** Run a single DoctorCheck against the filesystem. */
+export async function runDoctorCheck(projectRoot: string, check: DoctorCheck): Promise<CheckResult> {
+  const fullPath = resolve(projectRoot, check.path);
+
+  if (check.type === 'file') {
+    if (!existsSync(fullPath)) {
+      return { ok: false, label: check.label, detail: `${check.path} not found` };
     }
-    checks.push({ ide: ide as string, file: configFile, found: existsSync(resolve(projectRoot, configFile)) });
+    return { ok: true, label: check.label };
   }
 
-  const missing = checks.filter((c) => !c.found);
-  if (missing.length > 0) {
-    return { ok: false, label: 'IDE configuration files', detail: `Missing: ${missing.map((m) => `${m.ide} (${m.file})`).join(', ')}` };
+  // type === 'dir'
+  if (!existsSync(fullPath)) {
+    return { ok: false, label: check.label, detail: `${check.path} not found` };
   }
-  return { ok: true, label: 'IDE configuration files', detail: `${checks.length} IDE(s) configured` };
-}
 
-async function checkMcpConfig(projectRoot: string, manifest: Manifest | null): Promise<CheckResult> {
-  if (!manifest) {
-    return { ok: false, label: 'MCP configuration', detail: 'No manifest — cannot check' };
-  }
-  const ides = manifest.ides ?? [manifest.ide];
-  const mcpPaths: Record<string, string> = {
-    vscode: '.vscode/mcp.json',
-    cursor: '.cursor/mcp.json',
-    'claude-code': '.claude/mcp.json',
-    opencode: 'mcp.json',
-  };
-
-  const found: string[] = [];
-  for (const ide of ides) {
-    const path = mcpPaths[ide as string];
-    if (path && existsSync(resolve(projectRoot, path))) {
-      found.push(ide as string);
+  if (check.countContents) {
+    const entries = await readdir(fullPath).catch(() => [] as string[]);
+    const filtered = check.countFilter
+      ? entries.filter((e) => e.endsWith(check.countFilter!))
+      : entries;
+    if (filtered.length === 0) {
+      return { ok: false, label: check.label, detail: `No files found in ${check.path}` };
     }
+    return { ok: true, label: check.label, detail: `${filtered.length} file(s)` };
+  }
+
+  return { ok: true, label: check.label };
+}
+
+/** Check MCP config presence from the adapter's customizable paths. */
+export function checkMcpFromPaths(projectRoot: string, mcpPaths: string[]): CheckResult {
+  if (mcpPaths.length === 0) {
+    return { ok: true, label: 'MCP configuration', detail: 'No MCP config path configured' };
   }
-  if (found.length === 0 && ides.length > 0) {
-    return { ok: true, label: 'MCP configuration', detail: 'No MCP config files found (MCP tools will not be available)', warning: true };
+  const found = mcpPaths.filter((p) => existsSync(resolve(projectRoot, p)));
+  if (found.length === 0) {
+    return {
+      ok: true,
+      label: 'MCP configuration',
+      detail: `No MCP config found (${mcpPaths.join(', ')}) — MCP tools unavailable`,
+      warning: true,
+    };
   }
   return { ok: true, label: 'MCP configuration', detail: `${found.length} MCP config(s)` };
 }
@@ -211,30 +167,71 @@ export default async function doctor({ args: _args }: CliContext): Promise<void>
 
   const manifest = await readManifest(projectRoot);
 
-  const results: CheckResult[] = [
+  // Shared checks (not IDE-specific)
+  const sharedResults: CheckResult[] = [
     checkManifest(manifest),
     await checkCustomizations(projectRoot),
-    await checkInstructions(projectRoot),
-    await checkAgents(projectRoot),
-    await checkSkills(projectRoot),
     await checkSkillMatrix(projectRoot),
     await checkLogs(projectRoot),
-    await checkIdeConfigs(projectRoot, manifest),
-    await checkMcpConfig(projectRoot, manifest),
     checkMcpEnvVars(manifest),
     await checkDotEnv(projectRoot, manifest),
   ];
 
-  for (const r of results) {
+  // IDE-specific checks derived from each adapter
+  type IdeGroup = { label: string; results: CheckResult[] };
+  const ideGroups: IdeGroup[] = [];
+
+  if (manifest) {
+    const ides = manifest.ides ?? (manifest.ide ? [manifest.ide] : []);
+    for (const ide of ides) {
+      const loader = IDE_ADAPTERS[ide];
+      if (!loader) continue;
+      const adapter = await loader();
+      const doctorChecks = adapter.getDoctorChecks();
+      const managedPaths = adapter.getManagedPaths();
+
+      const checkResults = await Promise.all(
+        doctorChecks.map((c) => runDoctorCheck(projectRoot, c))
+      );
+
+      // MCP config check — non-directory entries in the adapter's customizable paths
+      const mcpPaths = managedPaths.customizable.filter((p) => !p.endsWith('/'));
+      checkResults.push(checkMcpFromPaths(projectRoot, mcpPaths));
+
+      ideGroups.push({
+        label: IDE_LABELS[ide as IdeChoice] ?? ide,
+        results: checkResults,
+      });
+    }
+  }
+
+  // Print shared results
+  for (const r of sharedResults) {
     const icon = r.ok ? (r.warning ? WARN : PASS) : FAIL;
     const detail = r.detail ? `  ${DIM(r.detail)}` : '';
     console.log(`  ${icon} ${r.label}${detail}`);
   }
 
-  const failures = results.filter((r) => !r.ok);
-  const warnings = results.filter((r) => r.ok && r.warning);
+  // Print IDE-specific results, grouped with a header when multiple IDEs are configured
+  if (ideGroups.length > 0) {
+    console.log();
+    for (const group of ideGroups) {
+      if (ideGroups.length > 1) {
+        console.log(`  ${BOLD(`[${group.label}]`)}`);
+      }
+      for (const r of group.results) {
+        const icon = r.ok ? (r.warning ? WARN : PASS) : FAIL;
+        const detail = r.detail ? `  ${DIM(r.detail)}` : '';
+        console.log(`  ${icon} ${r.label}${detail}`);
+      }
+      if (ideGroups.length > 1) console.log();
+    }
+  }
+
+  const allResults = [...sharedResults, ...ideGroups.flatMap((g) => g.results)];
+  const failures = allResults.filter((r) => !r.ok);
+  const warnings = allResults.filter((r) => r.ok && r.warning);
 
-  console.log();
   if (failures.length > 0) {
     console.log(`  ${BOLD(`${failures.length} issue(s) found.`)} Run "npx opencastle init" to fix.\n`);
     process.exit(1);

package/src/cli/eject.ts

@@ -19,7 +19,7 @@ export default async function eject({
 
   console.log(`\n  🏰 OpenCastle eject\n`)
   console.log('  This will:')
-  console.log('    • Remove .opencastle.json (manifest)')
+  console.log('    • Remove .opencastle/manifest.json (manifest)')
   console.log('    • Keep ALL generated files as standalone')
   console.log(
     '    • You can safely uninstall the opencastle package after this\n'
@@ -36,7 +36,7 @@ export default async function eject({
     return
   }
 
-  await unlink(resolve(projectRoot, '.opencastle.json'))
+  await unlink(resolve(projectRoot, '.opencastle', 'manifest.json'))
 
   console.log('\n  ✓ Ejected. Files are now standalone.')
   console.log('  You can uninstall: npm uninstall opencastle\n')