@antomanc/aginit 0.4.1 → 0.5.0

package/src/cli/capabilities.ts

@@ -0,0 +1,176 @@
+import path from 'node:path';
+import pc from 'picocolors';
+import { AGINIT_CONFIG_FILENAME, AginitConfig } from '../config/schema.js';
+import { readProjectConfig, validateConfig } from '../config/validation.js';
+import { resolvePlatformStack } from '../adapters/agent-docs.js';
+import { installAllSkills, removeSkills, skillAgents } from '../adapters/skills.js';
+import { uninstallGraft } from '../adapters/graft.js';
+import { ignoreVendoredSkills } from '../adapters/tool-ignores.js';
+import {
+  activeIds,
+  applyResolvedProfile,
+  CapabilityCategory,
+  CapabilityDescriptor,
+  catalogFor,
+  findCapability,
+  inferCapabilities,
+  ProfileFlags,
+  resolveCapabilities,
+  sourcesFor
+} from '../registry/index.js';
+import { SETUPS } from '../registry/setup.js';
+import { writeJsonFile } from '../utils/fs.js';
+import { logger } from '../utils/logger.js';
+import { missingBinaries, syncAgentDocs } from './new.js';
+
+const CATEGORY_ORDER: CapabilityCategory[] = [
+  'codebase-graph',
+  'methodology',
+  'discipline',
+  'design',
+  'ui-driver',
+  'testing-engine',
+  'context-guard',
+  'custom'
+];
+
+/** Print the registry grouped by category, marking what the project has enabled. */
+export function listCapabilities(targetDir: string = process.cwd()): void {
+  const config = readProjectConfig(targetDir);
+  const enabled = config ? activeIds(config) : new Set<string>();
+  logger.banner(
+    'Aginit — Capability registry',
+    config ? `Enabled in ${AGINIT_CONFIG_FILENAME}: ●` : `No ${AGINIT_CONFIG_FILENAME} here; showing the catalog`
+  );
+  const catalog = catalogFor(config);
+  for (const category of CATEGORY_ORDER) {
+    const entries = catalog.filter((c) => c.category === category);
+    if (entries.length === 0) continue;
+    console.log(pc.bold(pc.underline(category)));
+    for (const c of entries) {
+      const mark = enabled.has(c.id) ? pc.green('●') : pc.dim('○');
+      const platforms = c.supportedPlatforms.join(', ');
+      console.log(`  ${mark} ${pc.bold(c.id.padEnd(22))} ${c.description}`);
+      console.log(pc.dim(`      ${platforms} · ${c.license} · ${c.repoUrl}`));
+    }
+    console.log();
+  }
+}
+
+export interface ChangeOptions {
+  dryRun?: boolean;
+  silent?: boolean;
+}
+
+function requireConfig(targetDir: string): AginitConfig {
+  const config = readProjectConfig(targetDir);
+  if (!config)
+    throw new Error(`No ${AGINIT_CONFIG_FILENAME} in ${targetDir}. Run \`aginit init\` first.`);
+  return config;
+}
+
+/** Skill names to remove; a source installed whole is removed by its repo. */
+const skillsOf = (capabilities: CapabilityDescriptor[]) =>
+  capabilities.flatMap((c) =>
+    c.install.flatMap((s) => (s.kind !== 'skills-sh' ? [] : s.skills.length ? s.skills : [s.repo]))
+  );
+
+/**
+ * Enable or disable capabilities, then bring the project in line: config,
+ * skills (installed or removed through the Skills CLI), upstream setups,
+ * AGENTS.md and docs/agents/. Picking a methodology, design or UI driver
+ * replaces the current one in that category.
+ */
+export async function changeCapabilities(
+  targetDir: string,
+  change: { add?: string[]; remove?: string[] },
+  options: ChangeOptions = {}
+): Promise<boolean> {
+  const { dryRun = false, silent = false } = options;
+  const config = requireConfig(targetDir);
+  const { platform, stack } = resolvePlatformStack(config, targetDir);
+  const base = config.capabilities ?? inferCapabilities(config);
+  const previous = [...base, ...(config.customCapabilities ?? []).map((c) => c.id)];
+  const before = activeIds(config);
+
+  const flags: ProfileFlags = { addons: [], addSkills: [], without: [] };
+  for (const id of change.add ?? []) {
+    const capability = findCapability(id, config);
+    if (!capability) {
+      if (id.includes('/')) flags.addSkills!.push(id);
+      else throw new Error(`Unknown capability "${id}". Run \`aginit list\` to see the registry.`);
+    } else if (capability.category === 'methodology') flags.methodology = id;
+    else if (capability.category === 'design') flags.design = id;
+    else if (capability.category === 'ui-driver' && !capability.addon) flags.uiDriver = id;
+    else flags.addons!.push(id);
+  }
+  for (const id of change.remove ?? []) {
+    if (!findCapability(id, config))
+      throw new Error(`Unknown capability "${id}". Run \`aginit list\` to see the registry.`);
+    flags.without!.push(id);
+  }
+  const custom = config.customCapabilities ?? [];
+  const customIds = new Set(custom.map((c) => c.id));
+  const disabled = (config.disabledCapabilities ?? []).filter((id) => !(change.add ?? []).includes(id));
+  const resolved = resolveCapabilities(
+    { platform, stack, framework: config.framework, base, basePlatform: platform, flags, custom },
+    disabled
+  );
+  // A removed custom capability is gone, not disabled.
+  resolved.disabledCapabilities = resolved.disabledCapabilities.filter((id) => !customIds.has(id));
+  const next = validateConfig(
+    applyResolvedProfile({ ...config, platform, stack }, resolved, { skills: true, previous })
+  );
+  // Adding graft or playwright turns their legacy switch back on.
+  if (next.capabilities?.includes('graft')) next.codebase.graft = true;
+
+  const after = activeIds(next);
+  const nextCatalog = catalogFor(next);
+  const added = nextCatalog.filter((c) => after.has(c.id) && !before.has(c.id));
+  const removed = catalogFor(config).filter((c) => before.has(c.id) && !after.has(c.id));
+  if (added.length === 0 && removed.length === 0 && JSON.stringify(next) === JSON.stringify(config)) {
+    if (!silent) logger.info('Nothing to change.');
+    return true;
+  }
+  if (!silent) {
+    for (const c of added) logger.success(`Enabling ${c.id}`);
+    for (const c of removed) logger.warn(`Disabling ${c.id}`);
+  }
+
+  writeJsonFile(path.join(targetDir, AGINIT_CONFIG_FILENAME), next, { overwrite: true, dryRun, silent });
+  let ok = true;
+
+  ok = (await removeSkills(targetDir, skillsOf(removed), { dryRun, silent })) && ok;
+  if (removed.some((c) => c.id === 'graft')) await uninstallGraft(targetDir, { dryRun, silent });
+  const leftovers = removed.filter((c) =>
+    c.install.some((s) => s.kind === 'setup' && s.setup !== 'graft')
+  );
+  if (!silent)
+    for (const c of leftovers)
+      logger.dim(`${c.id}: files and global CLIs its setup created are left in place; remove them by hand.`);
+
+  const addedSources = sourcesFor(added);
+  if (addedSources.length > 0) {
+    const { failed } = await installAllSkills(targetDir, addedSources, {
+      agents: skillAgents(next),
+      dryRun,
+      silent
+    });
+    ok = failed.length === 0 && ok;
+    for (const line of ignoreVendoredSkills(targetDir, { dryRun, silent: true })) logger.warn(line);
+  }
+  for (const c of added)
+    for (const step of c.install)
+      if (step.kind === 'setup')
+        ok = (await SETUPS[step.setup]({ targetDir, config: next, platform, stack, dryRun, silent })) && ok;
+
+  syncAgentDocs(targetDir, next, { dryRun, silent });
+  if (!silent)
+    for (const { name, bin, install } of await missingBinaries(added, ['graft', 'agent-browser', 'e2e']))
+      logger.warn(`${name} needs the \`${bin}\` CLI: ${install}`);
+  if (!silent) {
+    if (ok) logger.success('Capabilities updated. AGENTS.md and docs/agents/ are in sync.');
+    else logger.warn('Capabilities updated with warnings. Resolve them and rerun `aginit init`.');
+  }
+  return ok;
+}

package/src/cli/doctor.ts

@@ -17,7 +17,6 @@ import {
 } from '../adapters/skills.js';
 import { claudeMarkdownImportsAgents } from '../adapters/agents-md.js';
 import {
-  agentBrowserConfigured,
   agentBrowserStubInstalled,
   findUsernsRestriction,
   runAgentBrowserDiagnostics
@@ -25,10 +24,60 @@ import {
 import { readProjectConfig } from '../config/validation.js';
 import { vendoredSkillsExposure } from '../adapters/tool-ignores.js';
 import { logger } from '../utils/logger.js';
+import { activeCapabilities, activeIds, doctorChecks, isNodeStack } from '../registry/index.js';
+import { resolvePlatformStack } from '../adapters/agent-docs.js';
+
+/**
+ * One row per active capability, built from its registry entry: every skill
+ * file it installs, every CLI it drives and any artifact it declares.
+ */
+export async function capabilityChecks(
+  targetDir: string,
+  config: AginitConfig
+): Promise<CheckItem[]> {
+  const items: CheckItem[] = [];
+  for (const capability of activeCapabilities(config)) {
+    const problems: string[] = [];
+    const fixes: string[] = [];
+    const missingSkills: string[] = [];
+    const versions: string[] = [];
+    for (const check of doctorChecks(capability, config.skills.sources)) {
+      if (check.kind === 'file') {
+        if (fileExists(path.join(targetDir, check.path))) continue;
+        const skill = /^\.agents\/skills\/([^/]+)\/SKILL\.md$/.exec(check.path)?.[1];
+        if (skill) missingSkills.push(skill);
+        else {
+          problems.push(`${check.path} missing`);
+          fixes.push(check.fix);
+        }
+      } else if (!(await commandExists(check.bin))) {
+        problems.push(`${check.bin} CLI not found in PATH`);
+        fixes.push(check.fix);
+      } else {
+        const res = await runExecutable(check.bin, check.args, { silent: true, timeout: 30_000 });
+        versions.push(res.ok && res.stdout ? `${check.bin} ${res.stdout.split('\n')[0]}` : check.bin);
+      }
+    }
+    if (missingSkills.length) {
+      problems.unshift(`skills missing from .agents/skills/: ${missingSkills.join(', ')}`);
+      fixes.unshift('Run `aginit init` to reinstall the configured skills');
+    }
+    items.push({
+      name: `${capability.name} (${capability.category})`,
+      category: 'Capabilities',
+      ok: problems.length === 0,
+      detail: problems.length ? problems.join('; ') : `Ready${versions.length ? ` (${versions.join(', ')})` : ''}`,
+      suggestion: fixes.length ? fixes.join(' · ') : undefined
+    });
+  }
+  return items;
+}
+
+type CheckCategory = 'Environment' | 'AI Tooling' | 'Project Config' | 'Capabilities';
 
 interface CheckItem {
   name: string;
-  category: 'Environment' | 'AI Tooling' | 'Project Config';
+  category: CheckCategory;
   ok: boolean;
   version?: string;
   detail: string;
@@ -88,9 +137,14 @@ export async function runDoctor(targetDir: string = process.cwd()): Promise<void
     suggestion: nodeSuggestion
   });
 
-  // 2. Active Package Manager check (pnpm, npm, yarn, or bun)
-  const pmRes = await runExecutable(activePm, ['-v'], { silent: true });
-  checks.push({
+  // 2. Active Package Manager check (pnpm, npm, yarn, or bun); none for non-Node stacks
+  const { stack, platform } = projectConfig
+    ? resolvePlatformStack(projectConfig, targetDir)
+    : { stack: 'node' as const, platform: null };
+  const pmRes = isNodeStack(stack)
+    ? await runExecutable(activePm, ['-v'], { silent: true })
+    : null;
+  if (pmRes) checks.push({
     name: `${activePm} package manager`,
     category: 'Environment',
     ok: pmRes.ok,
@@ -133,22 +187,6 @@ export async function runDoctor(targetDir: string = process.cwd()): Promise<void
         : undefined
   });
 
-  // 4. Graft CLI check
-  const graftExists = await commandExists('graft');
-  let graftVersion = '';
-  if (graftExists) {
-    const gv = await runExecutable('graft', ['--version'], { silent: true });
-    graftVersion = gv.stdout;
-  }
-  checks.push({
-    name: 'Graft codebase graph CLI',
-    category: 'AI Tooling',
-    ok: graftExists,
-    version: graftVersion,
-    detail: graftExists ? `Installed globally (${graftVersion})` : 'Graft CLI not found in PATH',
-    suggestion: graftExists ? undefined : 'Install Graft: `npm install -g @nanonets/graft`'
-  });
-
   // 5. Codex CLI check
   const codexExists = await commandExists('codex');
   checks.push({
@@ -176,7 +214,7 @@ export async function runDoctor(targetDir: string = process.cwd()): Promise<void
     category: 'Project Config',
     ok: !!projectConfig,
     detail: projectConfig
-      ? `Preset: "${projectConfig.preset}" (v${projectConfig.schemaVersion || '1.0.0'}), pm: ${activePm}, agents: ${projectConfig.agents.primary}/${projectConfig.agents.secondary}${claudeCodeEnabled(projectConfig) ? '/claude-code' : ''}`
+      ? `Preset: "${projectConfig.preset}" (v${projectConfig.schemaVersion || '1.0.0'}), platform: ${platform} (${stack})${pmRes ? `, pm: ${activePm}` : ''}, agents: ${projectConfig.agents.primary}/${projectConfig.agents.secondary}${claudeCodeEnabled(projectConfig) ? '/claude-code' : ''}`
       : configError
         ? `Invalid configuration: ${configError}`
         : 'No aginit.config.json found in current directory',
@@ -290,47 +328,29 @@ export async function runDoctor(targetDir: string = process.cwd()): Promise<void
     });
   }
 
+  // 10. Registry: each active capability's checks (skill files, CLIs, artifacts)
+  if (projectConfig !== null) checks.push(...(await capabilityChecks(targetDir, projectConfig)));
+
   // 10. agent-browser runtime (only when the project ships the skill)
   const agentBrowserWanted =
     projectConfig !== null &&
-    (agentBrowserConfigured(projectConfig.skills.sources) || agentBrowserStubInstalled(targetDir));
-  if (agentBrowserWanted) {
-    const abExists = await commandExists('agent-browser');
-    let abVersion = '';
-    if (abExists) {
-      const av = await runExecutable('agent-browser', ['--version'], { silent: true });
-      abVersion = av.ok ? av.stdout : '';
-    }
-    checks.push({
-      name: 'agent-browser CLI',
-      category: 'AI Tooling',
-      ok: abExists,
-      version: abVersion,
-      detail: abExists
-        ? `Installed globally (${abVersion || 'version unknown'})`
-        : 'agent-browser skill is installed but the CLI is not in PATH',
-      suggestion: abExists
-        ? undefined
-        : 'Install the runtime: `npm i -g agent-browser && agent-browser install`'
-    });
-
-    if (abExists) {
-      const diagnostics = await runAgentBrowserDiagnostics();
-      if (diagnostics !== null) {
-        checks.push({
-          name: 'agent-browser browser runtime',
-          category: 'AI Tooling',
-          ok: diagnostics.length === 0,
-          detail:
-            diagnostics.length === 0
-              ? 'Upstream doctor reports browser and launch environment healthy'
-              : diagnostics.map((d) => d.message).join('; '),
-          suggestion:
-            diagnostics.length === 0
-              ? undefined
-              : (diagnostics.find((d) => d.fix)?.fix ?? 'Run `agent-browser doctor` for details')
-        });
-      }
+    (activeIds(projectConfig).has('agent-browser') || agentBrowserStubInstalled(targetDir));
+  if (agentBrowserWanted && (await commandExists('agent-browser'))) {
+    const diagnostics = await runAgentBrowserDiagnostics();
+    if (diagnostics !== null) {
+      checks.push({
+        name: 'agent-browser browser runtime',
+        category: 'AI Tooling',
+        ok: diagnostics.length === 0,
+        detail:
+          diagnostics.length === 0
+            ? 'Upstream doctor reports browser and launch environment healthy'
+            : diagnostics.map((d) => d.message).join('; '),
+        suggestion:
+          diagnostics.length === 0
+            ? undefined
+            : (diagnostics.find((d) => d.fix)?.fix ?? 'Run `agent-browser doctor` for details')
+      });
     }
   }
 
@@ -358,15 +378,12 @@ export async function runDoctor(targetDir: string = process.cwd()): Promise<void
   }
 
   // Print grouped results
-  const categories: Array<'Environment' | 'AI Tooling' | 'Project Config'> = [
-    'Environment',
-    'AI Tooling',
-    'Project Config'
-  ];
+  const categories: CheckCategory[] = ['Environment', 'AI Tooling', 'Project Config', 'Capabilities'];
 
   for (const cat of categories) {
-    console.log(pc.bold(pc.underline(cat)));
     const catChecks = checks.filter((c) => c.category === cat);
+    if (catChecks.length === 0) continue;
+    console.log(pc.bold(pc.underline(cat)));
     for (const c of catChecks) {
       const icon = c.ok ? pc.green('✓') : pc.yellow('⚠');
       const name = pc.bold(c.name);

package/src/cli/init.ts

@@ -24,7 +24,7 @@ export async function initCurrentDirectory(options: NewProjectOptions = {}): Pro
   else projectName = sanitizeProjectName(projectName);
 
   const packageManager =
-    options.packageManager ?? saved?.packageManager ?? detectPackageManager(currentDir) ?? 'pnpm';
+    options.packageManager ?? saved?.packageManager ?? detectPackageManager(currentDir) ?? undefined;
 
   return createProject(projectName, {
     ...options,

package/src/cli/main.ts

@@ -3,13 +3,15 @@ import { readFileSync } from 'node:fs';
 import { createProject } from './new.js';
 import { initCurrentDirectory } from './init.js';
 import { runDoctor } from './doctor.js';
-import { claudeCodeEnabled, ensureClaudeSkillLinks, updateSkills } from '../adapters/skills.js';
+import { ensureClaudeSkillLinks, updateSkills } from '../adapters/skills.js';
 import { ignoreVendoredSkills } from '../adapters/tool-ignores.js';
-import { setupClaudeMarkdown } from '../adapters/agents-md.js';
 import { buildGraft } from '../adapters/graft.js';
 import { readProjectConfig } from '../config/validation.js';
 import { logger } from '../utils/logger.js';
 import { PresetType, WebFramework, PackageManager } from '../config/schema.js';
+import { Platform, ProfileFlags, TestingChoice } from '../registry/index.js';
+import { changeCapabilities, listCapabilities } from './capabilities.js';
+import { syncAgentDocs } from './new.js';
 import {
   isInteractive,
   promptNewProject,
@@ -30,25 +32,85 @@ function readVersion(): string {
   }
 }
 
+const list = (value: string, previous: string[] = []) => [
+  ...previous,
+  ...value
+    .split(',')
+    .map((item) => item.trim())
+    .filter(Boolean)
+];
+
+/** v2 profile options shared by the root command, `new` and `init`. */
+function withProfileOptions(command: Command): Command {
+  return command
+    .option('--platform <platform>', 'Platform: auto | web | mobile-native | mobile-rn | backend | cli')
+    .option('--methodology <preset>', 'Workflow skills: pocock | superpowers | minimal')
+    .option('--design <design>', 'Design system: impeccable | none')
+    .option('--testing <engine>', 'Testing: e2e | playwright | vitest | native')
+    .option('--ui-driver <driver>', 'UI driver: auto | agent-browser | agent-device | none')
+    .option('--addons <ids>', 'Add-ons: context-mode, worktrunk, chrome-devtools-mcp, browserskill', list)
+    .option('--add-skill <owner/repo>', 'Add a skill repository as a custom capability (repeatable)', list)
+    .option('--without <id>', 'Disable a capability, e.g. graft or humanizer (repeatable)', list);
+}
+
+function profileFlags(options: any): ProfileFlags {
+  return {
+    platform: options.platform === 'auto' ? undefined : (options.platform as Platform | undefined),
+    methodology: options.methodology,
+    design: options.design,
+    testing: options.testing as TestingChoice | undefined,
+    uiDriver: options.uiDriver,
+    addons: options.addons,
+    addSkills: options.addSkill,
+    without: options.without
+  };
+}
+
 export function createCliProgram(): Command {
   const program = new Command();
 
   program
     .name('aginit')
     .description('Set up a new or existing project for AI coding agents')
-    .version(readVersion());
-
-  // Root action: interactive wizard when in TTY, else display help
-  program.action(async () => {
-    if (isInteractive()) {
-      await runInteractiveWizard();
-    } else {
-      program.outputHelp();
+    .version(readVersion())
+    .enablePositionalOptions()
+    .option('-p, --preset <preset>', 'Project preset: web | cli | generic')
+    .option('-f, --framework <framework>', 'Web framework: none | vite | next | existing')
+    .option('-m, --package-manager <pm>', 'Package manager: pnpm | npm | yarn | bun')
+    .option('--no-skills', 'Skip installing AI skills')
+    .option('--no-graft', 'Skip codebase graph (Graft) setup')
+    .option('--no-git', 'Skip git repository initialization')
+    .option('--dry-run', 'Simulate setup without writing changes to disk')
+    .option('-y, --yes', 'Initialize the current directory without prompts (saved or detected settings)');
+  withProfileOptions(program);
+
+  // Root action: `aginit [options]` initializes the current directory. Bare
+  // `aginit` opens the wizard in a TTY and prints help otherwise, so a stray
+  // invocation in CI never rewrites a project.
+  program.action(async (options: any, command: Command) => {
+    const explicit = command.options.some(
+      (option) => command.getOptionValueSource(option.attributeName()) === 'cli'
+    );
+    if (!explicit) {
+      if (isInteractive()) await runInteractiveWizard();
+      else program.outputHelp();
+      return;
     }
+    const complete = await initCurrentDirectory({
+      preset: options.preset as PresetType | undefined,
+      framework: options.framework as WebFramework | undefined,
+      packageManager: options.packageManager as PackageManager | undefined,
+      skills: options.skills,
+      graft: options.graft,
+      git: options.git,
+      dryRun: options.dryRun,
+      profile: profileFlags(options)
+    });
+    if (!complete && !options.dryRun) process.exitCode = 1;
   });
 
   // Command: new
-  program
+  const newCommand = program
     .command('new [projectName]')
     .description('Create a brand new AI-first project')
     .option('-p, --preset <preset>', 'Project preset: web | cli | generic', 'generic')
@@ -57,12 +119,14 @@ export function createCliProgram(): Command {
     .option('--no-skills', 'Skip installing AI skills')
     .option('--no-graft', 'Skip codebase graph (Graft) setup')
     .option('--no-git', 'Skip git repository initialization')
-    .option('--dry-run', 'Simulate creation without writing changes to disk')
+    .option('--dry-run', 'Simulate creation without writing changes to disk');
+  withProfileOptions(newCommand)
     .action(async (projectName: string | undefined, options: any, command: Command) => {
       let finalName = projectName;
       let finalPreset = options.preset;
       let finalFramework = options.framework;
       let finalPackageManager = options.packageManager;
+      let finalProfile = profileFlags(options);
 
       if (!finalName) {
         if (!isInteractive()) {
@@ -80,12 +144,14 @@ export function createCliProgram(): Command {
           packageManager:
             command.getOptionValueSource('packageManager') === 'cli'
               ? (options.packageManager as PackageManager)
-              : undefined
+              : undefined,
+          profile: finalProfile
         });
         finalName = answers.projectName;
         finalPreset = answers.preset;
         finalFramework = answers.framework;
         finalPackageManager = answers.packageManager;
+        finalProfile = answers.profile;
       }
 
       const complete = await createProject(finalName, {
@@ -95,13 +161,14 @@ export function createCliProgram(): Command {
         skills: options.skills,
         graft: options.graft,
         git: options.git,
-        dryRun: options.dryRun
+        dryRun: options.dryRun,
+        profile: finalProfile
       });
       if (!complete && !options.dryRun) process.exitCode = 1;
     });
 
   // Command: init
-  program
+  const initCommand = program
     .command('init')
     .description('Initialize or update AI-first capabilities in the current directory')
     .option('-p, --preset <preset>', 'Project preset: web | cli | generic')
@@ -111,25 +178,30 @@ export function createCliProgram(): Command {
     .option('--no-graft', 'Skip codebase graph (Graft) setup')
     .option('--no-git', 'Skip git repository initialization')
     .option('--dry-run', 'Simulate setup without writing changes to disk')
+    .option('-y, --yes', 'Skip the prompts and use saved or detected settings');
+  withProfileOptions(initCommand)
     .action(async (options: any, command: Command) => {
       let finalPreset = options.preset;
       let finalFramework = options.framework;
       let finalPackageManager = options.packageManager;
+      let finalProfile = profileFlags(options);
 
       const isPresetExplicit = command.getOptionValueSource('preset') === 'cli';
       const isFrameworkExplicit = command.getOptionValueSource('framework') === 'cli';
       const isPmExplicit = command.getOptionValueSource('packageManager') === 'cli';
 
       const savedConfig = readProjectConfig(process.cwd());
-      if (isInteractive() && !isPresetExplicit && !options.dryRun && !savedConfig) {
+      if (isInteractive() && !isPresetExplicit && !options.dryRun && !options.yes && !savedConfig) {
         const answers = await promptInitProject({
           preset: isPresetExplicit ? (options.preset as PresetType) : undefined,
           framework: isFrameworkExplicit ? (options.framework as WebFramework) : undefined,
-          packageManager: isPmExplicit ? (options.packageManager as PackageManager) : undefined
+          packageManager: isPmExplicit ? (options.packageManager as PackageManager) : undefined,
+          profile: finalProfile
         });
         finalPreset = answers.preset;
         finalFramework = answers.framework;
         finalPackageManager = answers.packageManager;
+        finalProfile = answers.profile;
       }
 
       const complete = await initCurrentDirectory({
@@ -139,11 +211,45 @@ export function createCliProgram(): Command {
         skills: options.skills,
         graft: options.graft,
         git: options.git,
-        dryRun: options.dryRun
+        dryRun: options.dryRun,
+        profile: finalProfile
       });
       if (!complete && !options.dryRun) process.exitCode = 1;
     });
 
+  // Command: list
+  program
+    .command('list')
+    .description('List every capability in the registry and which ones this project enables')
+    .option('-d, --dir <path>', 'Project directory', process.cwd())
+    .action((options: any) => listCapabilities(options.dir));
+
+  // Command: add
+  program
+    .command('add <capabilities...>')
+    .description('Enable capabilities (registry ids or owner/repo skill repositories)')
+    .option('--dry-run', 'Simulate the change')
+    .action(async (ids: string[], options: any) => {
+      const ok = await changeCapabilities(process.cwd(), { add: ids.flatMap((id) => list(id)) }, {
+        dryRun: options.dryRun
+      });
+      if (!ok && !options.dryRun) process.exitCode = 1;
+    });
+
+  // Command: remove
+  program
+    .command('remove <capabilities...>')
+    .description('Disable capabilities and remove the skills they installed')
+    .option('--dry-run', 'Simulate the change')
+    .action(async (ids: string[], options: any) => {
+      const ok = await changeCapabilities(
+        process.cwd(),
+        { remove: ids.flatMap((id) => list(id)) },
+        { dryRun: options.dryRun }
+      );
+      if (!ok && !options.dryRun) process.exitCode = 1;
+    });
+
   // Command: doctor
   program
     .command('doctor')
@@ -167,8 +273,7 @@ export function createCliProgram(): Command {
           ? true
           : await updateSkills(targetDir, { dryRun: options.dryRun })) &&
         (config ? await ensureClaudeSkillLinks(targetDir, config, { dryRun: options.dryRun }) : true);
-      if (config && claudeCodeEnabled(config))
-        setupClaudeMarkdown(targetDir, { dryRun: options.dryRun });
+      if (config) syncAgentDocs(targetDir, config, { dryRun: options.dryRun });
       if (config?.skills.sources.length !== 0) {
         const advice = ignoreVendoredSkills(targetDir, { dryRun: options.dryRun, silent: true });
         for (const line of advice) logger.warn(line);