opencastle 0.19.0 → 0.20.0

package/src/cli/adapters/cursor.ts

@@ -4,7 +4,7 @@ import { existsSync } from 'node:fs'
 import { copyDir, getOrchestratorRoot, removeDirIfExists, getPluginsRoot, getPluginSkillEntries } from '../copy.js'
 import { scaffoldMcpConfig } from '../mcp.js'
 import { getExcludedSkills, getExcludedAgents, getCustomizationsTransform, getIncludedPluginIds } from '../stack-config.js'
-import type { CopyResults, ManagedPaths, RepoInfo, StackConfig } from '../types.js'
+import type { CopyResults, DoctorCheck, ManagedPaths, RepoInfo, StackConfig } from '../types.js'
 import { splitFrontmatter, parseFrontmatterString } from './frontmatter.js'
 
 /**
@@ -317,6 +317,17 @@ export function getManagedPaths(): ManagedPaths {
   }
 }
 
+export function getDoctorChecks(): DoctorCheck[] {
+  return [
+    { label: 'Cursor rules file', path: '.cursorrules', type: 'file' },
+    { label: 'Instruction rules', path: '.cursor/rules/', type: 'dir', countContents: true, countFilter: '.mdc' },
+    { label: 'Agent rules', path: '.cursor/rules/agents/', type: 'dir', countContents: true, countFilter: '.mdc' },
+    { label: 'Skill rules', path: '.cursor/rules/skills/', type: 'dir', countContents: true, countFilter: '.mdc' },
+    { label: 'Workflow rules', path: '.cursor/rules/agent-workflows/', type: 'dir', countContents: true },
+    { label: 'Prompt rules', path: '.cursor/rules/prompts/', type: 'dir', countContents: true },
+  ]
+}
+
 // ─── Internal helpers ─────────────────────────────────────────────
 
 interface ConvertDirOptions {

package/src/cli/adapters/opencode.ts

@@ -16,7 +16,7 @@ import { createSingleFileAdapter } from './single-file-base.js'
 
 export const IDE_ID = 'opencode'
 
-const { install, update, getManagedPaths } = createSingleFileAdapter({
+const { install, update, getManagedPaths, getDoctorChecks } = createSingleFileAdapter({
   rootFile: 'AGENTS.md',
   dotDir: '.opencode',
   mcpConfigPath: 'opencode.json',
@@ -27,5 +27,5 @@ const { install, update, getManagedPaths } = createSingleFileAdapter({
   frameworkDirs: ['agents', 'skills', 'prompts', 'workflows'],
 })
 
-export { install, update, getManagedPaths }
+export { install, update, getManagedPaths, getDoctorChecks }
 

package/src/cli/adapters/single-file-base.ts

@@ -4,7 +4,7 @@ import { existsSync } from 'node:fs'
 import { copyDir, getOrchestratorRoot, getPluginsRoot, getPluginSkillEntries } from '../copy.js'
 import { scaffoldMcpConfig } from '../mcp.js'
 import { getExcludedSkills, getExcludedAgents, getCustomizationsTransform, getIncludedPluginIds } from '../stack-config.js'
-import type { CopyResults, IdeAdapter, IdeChoice, ManagedPaths, RepoInfo, StackConfig } from '../types.js'
+import type { CopyResults, DoctorCheck, IdeAdapter, IdeChoice, ManagedPaths, RepoInfo, StackConfig } from '../types.js'
 import { stripFrontmatter, parseFrontmatterMeta } from './frontmatter.js'
 
 /**
@@ -316,5 +316,20 @@ export function createSingleFileAdapter(config: SingleFileAdapterConfig): IdeAda
     }
   }
 
-  return { install, update, getManagedPaths }
+  function getDoctorChecks(): DoctorCheck[] {
+    const checks: DoctorCheck[] = [
+      { label: 'Root instructions file', path: config.rootFile, type: 'file' },
+      { label: 'Agent definitions', path: `${config.dotDir}/agents/`, type: 'dir', countContents: true, countFilter: '.md' },
+      { label: 'Skills directory', path: `${config.dotDir}/skills/`, type: 'dir', countContents: true, countFilter: '.md' },
+    ]
+    if (config.promptsDir === config.workflowsDir) {
+      checks.push({ label: 'Commands directory', path: `${config.dotDir}/${config.promptsDir}/`, type: 'dir', countContents: true })
+    } else {
+      checks.push({ label: 'Prompts directory', path: `${config.dotDir}/${config.promptsDir}/`, type: 'dir', countContents: true })
+      checks.push({ label: 'Workflows directory', path: `${config.dotDir}/${config.workflowsDir}/`, type: 'dir', countContents: true })
+    }
+    return checks
+  }
+
+  return { install, update, getManagedPaths, getDoctorChecks }
 }

package/src/cli/adapters/vscode.ts

@@ -4,7 +4,7 @@ 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 type { CopyResults, CopyDirOptions, DoctorCheck, ManagedPaths, RepoInfo, StackConfig } from '../types.js'
 
 /**
  * VS Code / GitHub Copilot adapter.
@@ -200,3 +200,14 @@ export function getManagedPaths(): ManagedPaths {
     ],
   }
 }
+
+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/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 ─────────────────────────────────────
 
@@ -43,6 +45,7 @@ async function checkSkillMatrix(projectRoot: string): Promise<CheckResult> {
   if (!existsSync(path)) {
     return { ok: false, label: 'Skill matrix', detail: 'File not found at .github/customizations/agents/skill-matrix.json' };
   }
+  const { readFile } = await import('node:fs/promises');
   const content = await readFile(path, 'utf8');
   try {
     const data = JSON.parse(content);
@@ -59,41 +62,6 @@ 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');
   if (!existsSync(dir)) {
@@ -102,7 +70,6 @@ async function checkLogs(projectRoot: string): Promise<CheckResult> {
   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/types.ts

@@ -94,11 +94,26 @@ export interface ManagedPaths {
   customizable: string[];
 }
 
+/** Structure check for the doctor command — describes expected files/dirs per IDE. */
+export interface DoctorCheck {
+  /** Human-friendly label for the check */
+  label: string;
+  /** Relative path to a file or directory (ending with /) to check exists */
+  path: string;
+  /** 'file' or 'dir' */
+  type: 'file' | 'dir';
+  /** If true, counts the contents and reports count */
+  countContents?: boolean;
+  /** File extension filter when counting (e.g. '.md', '.mdc', '.agent.md') */
+  countFilter?: string;
+}
+
 /** IDE adapter interface (init/update commands). */
 export interface IdeAdapter {
   install(_pkgRoot: string, _projectRoot: string, _stack?: StackConfig, _repoInfo?: RepoInfo): Promise<CopyResults>;
   update(_pkgRoot: string, _projectRoot: string, _stack?: StackConfig): Promise<CopyResults>;
   getManagedPaths(): ManagedPaths;
+  getDoctorChecks(): DoctorCheck[];
 }
 
 /** Select prompt option. */

package/src/dashboard/node_modules/.vite/deps/_metadata.json

@@ -1,25 +1,25 @@
 {
-  "hash": "37afd6de",
+  "hash": "1338aa44",
   "configHash": "30f8ea04",
-  "lockfileHash": "fc91404e",
-  "browserHash": "4ed40789",
+  "lockfileHash": "56ae5b5d",
+  "browserHash": "aaeb6157",
   "optimized": {
     "astro > cssesc": {
       "src": "../../../../../node_modules/cssesc/cssesc.js",
       "file": "astro___cssesc.js",
-      "fileHash": "797719d6",
+      "fileHash": "2e7de42e",
       "needsInterop": true
     },
     "astro > aria-query": {
       "src": "../../../../../node_modules/aria-query/lib/index.js",
       "file": "astro___aria-query.js",
-      "fileHash": "92b9b174",
+      "fileHash": "4d71b8ca",
       "needsInterop": true
     },
     "astro > axobject-query": {
       "src": "../../../../../node_modules/axobject-query/lib/index.js",
       "file": "astro___axobject-query.js",
-      "fileHash": "b81bf886",
+      "fileHash": "aa82361e",
       "needsInterop": true
     }
   },