The agent harness performance optimization system. Skills, instincts, memory, security, and research-first development for Claude Code, Codex, Opencode, Cursor and beyond.
feat: implement --with/--without selective install flags (#679)
Affaan Mustafa07f6156d8a11
diff --git a/manifests/install-components.json b/manifests/install-components.jsonindex 3e58bc1d1..ef6ccf012 100644--- a/manifests/install-components.json+++ b/manifests/install-components.json@@ -250,6 +250,158 @@"modules": ["document-processing"]+ },+ {+ "id": "agent:architect",+ "family": "agent",+ "description": "System design and architecture agent.",+ "modules": [+ "agents-core"+ ]+ },+ {+ "id": "agent:code-reviewer",+ "family": "agent",+ "description": "Code review agent for quality and security checks.",+ "modules": [+ "agents-core"+ ]+ },+ {+ "id": "agent:security-reviewer",+ "family": "agent",+ "description": "Security vulnerability analysis agent.",+ "modules": [+ "agents-core"+ ]+ },+ {+ "id": "agent:tdd-guide",+ "family": "agent",+ "description": "Test-driven development guidance agent.",+ "modules": [+ "agents-core"+ ]+ },+ {+ "id": "agent:planner",+ "family": "agent",+ "description": "Feature implementation planning agent.",+ "modules": [+ "agents-core"+ ]+ },+ {+ "id": "agent:build-error-resolver",+ "family": "agent",+ "description": "Build error resolution agent.",+ "modules": [+ "agents-core"+ ]+ },+ {+ "id": "agent:e2e-runner",+ "family": "agent",+ "description": "Playwright E2E testing agent.",+ "modules": [+ "agents-core"+ ]+ },+ {+ "id": "agent:refactor-cleaner",+ "family": "agent",+ "description": "Dead code cleanup and refactoring agent.",+ "modules": [+ "agents-core"+ ]+ },+ {+ "id": "agent:doc-updater",+ "family": "agent",+ "description": "Documentation update agent.",+ "modules": [+ "agents-core"+ ]+ },+ {+ "id": "skill:tdd-workflow",+ "family": "skill",+ "description": "Test-driven development workflow skill.",+ "modules": [+ "workflow-quality"+ ]+ },+ {+ "id": "skill:continuous-learning",+ "family": "skill",+ "description": "Session pattern extraction and continuous learning skill.",+ "modules": [+ "workflow-quality"+ ]+ },+ {+ "id": "skill:eval-harness",+ "family": "skill",+ "description": "Evaluation harness for AI regression testing.",+ "modules": [+ "workflow-quality"+ ]+ },+ {+ "id": "skill:verification-loop",+ "family": "skill",+ "description": "Verification loop for code quality assurance.",+ "modules": [+ "workflow-quality"+ ]+ },+ {+ "id": "skill:strategic-compact",+ "family": "skill",+ "description": "Strategic context compaction for long sessions.",+ "modules": [+ "workflow-quality"+ ]+ },+ {+ "id": "skill:coding-standards",+ "family": "skill",+ "description": "Language-agnostic coding standards and best practices.",+ "modules": [+ "framework-language"+ ]+ },+ {+ "id": "skill:frontend-patterns",+ "family": "skill",+ "description": "React and frontend engineering patterns.",+ "modules": [+ "framework-language"+ ]+ },+ {+ "id": "skill:backend-patterns",+ "family": "skill",+ "description": "API design, database, and backend engineering patterns.",+ "modules": [+ "framework-language"+ ]+ },+ {+ "id": "skill:security-review",+ "family": "skill",+ "description": "Security review checklist and vulnerability analysis.",+ "modules": [+ "security"+ ]+ },+ {+ "id": "skill:deep-research",+ "family": "skill",+ "description": "Deep research and investigation workflows.",+ "modules": [+ "research-apis"+ ]}]}diff --git a/schemas/install-components.schema.json b/schemas/install-components.schema.jsonindex c90fefc82..c77878dae 100644--- a/schemas/install-components.schema.json+++ b/schemas/install-components.schema.json@@ -26,7 +26,7 @@"properties": {"id": {"type": "string",- "pattern": "^(baseline|lang|framework|capability):[a-z0-9-]+$"+ "pattern": "^(baseline|lang|framework|capability|agent|skill):[a-z0-9-]+$"},"family": {"type": "string",@@ -34,7 +34,9 @@"baseline","language","framework",- "capability"+ "capability",+ "agent",+ "skill"]},"description": {diff --git a/scripts/lib/install-manifests.js b/scripts/lib/install-manifests.jsindex 99c4102eb..a935ac68c 100644--- a/scripts/lib/install-manifests.js+++ b/scripts/lib/install-manifests.js@@ -10,6 +10,8 @@ const COMPONENT_FAMILY_PREFIXES = {language: 'lang:',framework: 'framework:',capability: 'capability:',+ agent: 'agent:',+ skill: 'skill:',};const LEGACY_COMPAT_BASE_MODULE_IDS_BY_TARGET = Object.freeze({claude: [diff --git a/tests/lib/selective-install.test.js b/tests/lib/selective-install.test.jsnew file mode 100644index 000000000..f15fab332--- /dev/null+++ b/tests/lib/selective-install.test.js@@ -0,0 +1,718 @@+/**+ * Tests for --with / --without selective install flags (issue #470)+ *+ * Covers:+ * - CLI argument parsing for --with and --without+ * - Request normalization with include/exclude component IDs+ * - Component-to-module expansion via the manifest catalog+ * - End-to-end install plans with --with and --without+ * - Validation and error handling for unknown component IDs+ * - Combined --profile + --with + --without flows+ * - Standalone --with without a profile+ * - agent: and skill: component families+ */++const assert = require('assert');+const fs = require('fs');+const os = require('os');+const path = require('path');++const {+ parseInstallArgs,+ normalizeInstallRequest,+} = require('../../scripts/lib/install/request');++const {+ loadInstallManifests,+ listInstallComponents,+ resolveInstallPlan,+} = require('../../scripts/lib/install-manifests');++function test(name, fn) {+ try {+ fn();+ console.log(` \u2713 ${name}`);+ return true;+ } catch (error) {+ console.log(` \u2717 ${name}`);+ console.log(` Error: ${error.message}`);+ return false;+ }+}++function runTests() {+ console.log('\n=== Testing --with / --without selective install flags ===\n');++ let passed = 0;+ let failed = 0;++ // ─── CLI Argument Parsing ───++ if (test('parses single --with flag', () => {+ const parsed = parseInstallArgs([+ 'node', 'install-apply.js',+ '--profile', 'core',+ '--with', 'lang:typescript',+ ]);+ assert.deepStrictEqual(parsed.includeComponentIds, ['lang:typescript']);+ assert.deepStrictEqual(parsed.excludeComponentIds, []);+ })) passed++; else failed++;++ if (test('parses single --without flag', () => {+ const parsed = parseInstallArgs([+ 'node', 'install-apply.js',+ '--profile', 'developer',+ '--without', 'capability:orchestration',+ ]);+ assert.deepStrictEqual(parsed.excludeComponentIds, ['capability:orchestration']);+ assert.deepStrictEqual(parsed.includeComponentIds, []);+ })) passed++; else failed++;++ if (test('parses multiple --with flags', () => {+ const parsed = parseInstallArgs([+ 'node', 'install-apply.js',+ '--with', 'lang:typescript',+ '--with', 'framework:nextjs',+ '--with', 'capability:database',+ ]);+ assert.deepStrictEqual(parsed.includeComponentIds, [+ 'lang:typescript',+ 'framework:nextjs',+ 'capability:database',+ ]);+ })) passed++; else failed++;++ if (test('parses multiple --without flags', () => {+ const parsed = parseInstallArgs([+ 'node', 'install-apply.js',+ '--profile', 'full',+ '--without', 'capability:media',+ '--without', 'capability:social',+ ]);+ assert.deepStrictEqual(parsed.excludeComponentIds, [+ 'capability:media',+ 'capability:social',+ ]);+ })) passed++; else failed++;++ if (test('parses combined --with and --without flags', () => {+ const parsed = parseInstallArgs([+ 'node', 'install-apply.js',+ '--profile', 'developer',+ '--with', 'lang:typescript',+ '--with', 'framework:nextjs',+ '--without', 'capability:orchestration',+ ]);+ assert.strictEqual(parsed.profileId, 'developer');+ assert.deepStrictEqual(parsed.includeComponentIds, ['lang:typescript', 'framework:nextjs']);+ assert.deepStrictEqual(parsed.excludeComponentIds, ['capability:orchestration']);+ })) passed++; else failed++;++ if (test('ignores empty --with values', () => {+ const parsed = parseInstallArgs([+ 'node', 'install-apply.js',+ '--with', '',+ '--with', 'lang:python',+ ]);+ assert.deepStrictEqual(parsed.includeComponentIds, ['lang:python']);+ })) passed++; else failed++;++ if (test('ignores empty --without values', () => {+ const parsed = parseInstallArgs([+ 'node', 'install-apply.js',+ '--profile', 'core',+ '--without', '',+ '--without', 'capability:media',+ ]);+ assert.deepStrictEqual(parsed.excludeComponentIds, ['capability:media']);+ })) passed++; else failed++;++ // ─── Request Normalization ───++ if (test('normalizes --with-only request as manifest mode', () => {+ const request = normalizeInstallRequest({+ target: 'claude',+ profileId: null,+ moduleIds: [],+ includeComponentIds: ['lang:typescript'],+ excludeComponentIds: [],+ languages: [],+ });+ assert.strictEqual(request.mode, 'manifest');+ assert.deepStrictEqual(request.includeComponentIds, ['lang:typescript']);+ assert.deepStrictEqual(request.excludeComponentIds, []);+ })) passed++; else failed++;++ if (test('normalizes --profile + --with + --without as manifest mode', () => {+ const request = normalizeInstallRequest({+ target: 'cursor',+ profileId: 'developer',+ moduleIds: [],+ includeComponentIds: ['lang:typescript', 'framework:nextjs'],+ excludeComponentIds: ['capability:orchestration'],+ languages: [],+ });+ assert.strictEqual(request.mode, 'manifest');+ assert.strictEqual(request.profileId, 'developer');+ assert.deepStrictEqual(request.includeComponentIds, ['lang:typescript', 'framework:nextjs']);+ assert.deepStrictEqual(request.excludeComponentIds, ['capability:orchestration']);+ })) passed++; else failed++;++ if (test('rejects --with combined with legacy language arguments', () => {+ assert.throws(+ () => normalizeInstallRequest({+ target: 'claude',+ profileId: null,+ moduleIds: [],+ includeComponentIds: ['lang:typescript'],+ excludeComponentIds: [],+ languages: ['python'],+ }),+ /cannot be combined/+ );+ })) passed++; else failed++;++ if (test('rejects --without combined with legacy language arguments', () => {+ assert.throws(+ () => normalizeInstallRequest({+ target: 'claude',+ profileId: null,+ moduleIds: [],+ includeComponentIds: [],+ excludeComponentIds: ['capability:media'],+ languages: ['typescript'],+ }),+ /cannot be combined/+ );+ })) passed++; else failed++;++ if (test('deduplicates repeated --with component IDs', () => {+ const request = normalizeInstallRequest({+ target: 'claude',+ profileId: null,+ moduleIds: [],+ includeComponentIds: ['lang:typescript', 'lang:typescript', 'lang:python'],+ excludeComponentIds: [],+ languages: [],+ });+ assert.deepStrictEqual(request.includeComponentIds, ['lang:typescript', 'lang:python']);+ })) passed++; else failed++;++ if (test('deduplicates repeated --without component IDs', () => {+ const request = normalizeInstallRequest({+ target: 'claude',+ profileId: 'full',+ moduleIds: [],+ includeComponentIds: [],+ excludeComponentIds: ['capability:media', 'capability:media', 'capability:social'],+ languages: [],+ });+ assert.deepStrictEqual(request.excludeComponentIds, ['capability:media', 'capability:social']);+ })) passed++; else failed++;++ // ─── Component Catalog Validation ───++ if (test('component catalog includes lang: family entries', () => {+ const components = listInstallComponents({ family: 'language' });+ assert.ok(components.some(c => c.id === 'lang:typescript'), 'Should have lang:typescript');+ assert.ok(components.some(c => c.id === 'lang:python'), 'Should have lang:python');+ assert.ok(components.some(c => c.id === 'lang:go'), 'Should have lang:go');+ assert.ok(components.some(c => c.id === 'lang:java'), 'Should have lang:java');+ })) passed++; else failed++;++ if (test('component catalog includes framework: family entries', () => {+ const components = listInstallComponents({ family: 'framework' });+ assert.ok(components.some(c => c.id === 'framework:react'), 'Should have framework:react');+ assert.ok(components.some(c => c.id === 'framework:nextjs'), 'Should have framework:nextjs');+ assert.ok(components.some(c => c.id === 'framework:django'), 'Should have framework:django');+ assert.ok(components.some(c => c.id === 'framework:springboot'), 'Should have framework:springboot');+ })) passed++; else failed++;++ if (test('component catalog includes capability: family entries', () => {+ const components = listInstallComponents({ family: 'capability' });+ assert.ok(components.some(c => c.id === 'capability:database'), 'Should have capability:database');+ assert.ok(components.some(c => c.id === 'capability:security'), 'Should have capability:security');+ assert.ok(components.some(c => c.id === 'capability:orchestration'), 'Should have capability:orchestration');+ })) passed++; else failed++;++ if (test('component catalog includes agent: family entries', () => {+ const components = listInstallComponents({ family: 'agent' });+ assert.ok(components.length > 0, 'Should have at least one agent component');+ assert.ok(components.some(c => c.id === 'agent:security-reviewer'), 'Should have agent:security-reviewer');+ })) passed++; else failed++;++ if (test('component catalog includes skill: family entries', () => {+ const components = listInstallComponents({ family: 'skill' });+ assert.ok(components.length > 0, 'Should have at least one skill component');+ assert.ok(components.some(c => c.id === 'skill:continuous-learning'), 'Should have skill:continuous-learning');+ })) passed++; else failed++;++ // ─── Install Plan Resolution with --with ───++ if (test('--with alone resolves component modules and their dependencies', () => {+ const plan = resolveInstallPlan({+ includeComponentIds: ['lang:typescript'],+ target: 'claude',+ });+ assert.ok(plan.selectedModuleIds.includes('framework-language'),+ 'Should include the module behind lang:typescript');+ assert.ok(plan.selectedModuleIds.includes('rules-core'),+ 'Should include framework-language dependency rules-core');+ assert.ok(plan.selectedModuleIds.includes('platform-configs'),+ 'Should include framework-language dependency platform-configs');+ })) passed++; else failed++;++ if (test('--with adds modules on top of a profile', () => {+ const plan = resolveInstallPlan({+ profileId: 'core',+ includeComponentIds: ['capability:security'],+ target: 'claude',+ });+ // core profile modules+ assert.ok(plan.selectedModuleIds.includes('rules-core'));+ assert.ok(plan.selectedModuleIds.includes('workflow-quality'));+ // added by --with+ assert.ok(plan.selectedModuleIds.includes('security'),+ 'Should include security module from --with');+ })) passed++; else failed++;++ if (test('multiple --with flags union their modules', () => {+ const plan = resolveInstallPlan({+ includeComponentIds: ['lang:typescript', 'capability:database'],+ target: 'claude',+ });+ assert.ok(plan.selectedModuleIds.includes('framework-language'),+ 'Should include framework-language from lang:typescript');+ assert.ok(plan.selectedModuleIds.includes('database'),+ 'Should include database from capability:database');+ })) passed++; else failed++;++ // ─── Install Plan Resolution with --without ───++ if (test('--without excludes modules from a profile', () => {+ const plan = resolveInstallPlan({+ profileId: 'developer',+ excludeComponentIds: ['capability:orchestration'],+ target: 'claude',+ });+ assert.ok(!plan.selectedModuleIds.includes('orchestration'),+ 'Should exclude orchestration module');+ assert.ok(plan.excludedModuleIds.includes('orchestration'),+ 'Should report orchestration as excluded');+ // rest of developer profile should remain+ assert.ok(plan.selectedModuleIds.includes('rules-core'));+ assert.ok(plan.selectedModuleIds.includes('framework-language'));+ assert.ok(plan.selectedModuleIds.includes('database'));+ })) passed++; else failed++;++ if (test('multiple --without flags exclude multiple modules', () => {+ const plan = resolveInstallPlan({+ profileId: 'full',+ excludeComponentIds: ['capability:media', 'capability:social', 'capability:supply-chain'],+ target: 'claude',+ });+ assert.ok(!plan.selectedModuleIds.includes('media-generation'));+ assert.ok(!plan.selectedModuleIds.includes('social-distribution'));+ assert.ok(!plan.selectedModuleIds.includes('supply-chain-domain'));+ assert.ok(plan.excludedModuleIds.includes('media-generation'));+ assert.ok(plan.excludedModuleIds.includes('social-distribution'));+ assert.ok(plan.excludedModuleIds.includes('supply-chain-domain'));+ })) passed++; else failed++;++ // ─── Combined --with + --without ───++ if (test('--with and --without work together on a profile', () => {+ const plan = resolveInstallPlan({+ profileId: 'developer',+ includeComponentIds: ['capability:security'],+ excludeComponentIds: ['capability:orchestration'],+ target: 'claude',+ });+ assert.ok(plan.selectedModuleIds.includes('security'),+ 'Should include security from --with');+ assert.ok(!plan.selectedModuleIds.includes('orchestration'),+ 'Should exclude orchestration from --without');+ assert.ok(plan.selectedModuleIds.includes('rules-core'),+ 'Should keep profile base modules');+ })) passed++; else failed++;++ if (test('--without on a dependency of --with raises an error', () => {+ assert.throws(+ () => resolveInstallPlan({+ includeComponentIds: ['capability:social'],+ excludeComponentIds: ['capability:content'],+ }),+ /depends on excluded module/+ );+ })) passed++; else failed++;++ // ─── Validation Errors ───++ if (test('throws for unknown component ID in --with', () => {+ assert.throws(+ () => resolveInstallPlan({+ includeComponentIds: ['lang:brainfuck-plus-plus'],+ }),+ /Unknown install component/+ );+ })) passed++; else failed++;++ if (test('throws for unknown component ID in --without', () => {+ assert.throws(+ () => resolveInstallPlan({+ profileId: 'core',+ excludeComponentIds: ['capability:teleportation'],+ }),+ /Unknown install component/+ );+ })) passed++; else failed++;++ if (test('throws when all modules are excluded', () => {+ assert.throws(+ () => resolveInstallPlan({+ profileId: 'core',+ excludeComponentIds: [+ 'baseline:rules',+ 'baseline:agents',+ 'baseline:commands',+ 'baseline:hooks',+ 'baseline:platform',+ 'baseline:workflow',+ ],+ target: 'claude',+ }),+ /excludes every requested install module/+ );+ })) passed++; else failed++;++ // ─── Target-Specific Behavior ───++ if (test('--with respects target compatibility filtering', () => {+ const plan = resolveInstallPlan({+ includeComponentIds: ['capability:orchestration'],+ target: 'cursor',+ });+ // orchestration module only supports claude, codex, opencode+ assert.ok(!plan.selectedModuleIds.includes('orchestration'),+ 'Should skip orchestration for cursor target');+ assert.ok(plan.skippedModuleIds.includes('orchestration'),+ 'Should report orchestration as skipped for cursor');+ })) passed++; else failed++;++ if (test('--without with agent: component excludes the agent module', () => {+ const plan = resolveInstallPlan({+ profileId: 'core',+ excludeComponentIds: ['agent:security-reviewer'],+ target: 'claude',+ });+ // agent:security-reviewer maps to agents-core module+ // Since core profile includes agents-core and it is excluded, it should be gone+ assert.ok(!plan.selectedModuleIds.includes('agents-core'),+ 'Should exclude agents-core when agent:security-reviewer is excluded');+ assert.ok(plan.excludedModuleIds.includes('agents-core'),+ 'Should report agents-core as excluded');+ })) passed++; else failed++;++ if (test('--with agent: component includes the agents-core module', () => {+ const plan = resolveInstallPlan({+ includeComponentIds: ['agent:security-reviewer'],+ target: 'claude',+ });+ assert.ok(plan.selectedModuleIds.includes('agents-core'),+ 'Should include agents-core module from agent:security-reviewer');+ })) passed++; else failed++;++ if (test('--with skill: component includes the parent skill module', () => {+ const plan = resolveInstallPlan({+ includeComponentIds: ['skill:continuous-learning'],+ target: 'claude',+ });+ assert.ok(plan.selectedModuleIds.includes('workflow-quality'),+ 'Should include workflow-quality module from skill:continuous-learning');+ })) passed++; else failed++;++ // ─── Help Text ───++ if (test('help text documents --with and --without flags', () => {+ const { execFileSync } = require('child_process');+ const scriptPath = path.join(__dirname, '..', '..', 'scripts', 'install-apply.js');+ const result = execFileSync('node', [scriptPath, '--help'], {+ encoding: 'utf8',+ stdio: ['pipe', 'pipe', 'pipe'],+ });+ assert.ok(result.includes('--with'), 'Help should mention --with');+ assert.ok(result.includes('--without'), 'Help should mention --without');+ assert.ok(result.includes('component'), 'Help should describe components');+ })) passed++; else failed++;++ // ─── End-to-End Dry-Run ───++ if (test('end-to-end: --profile developer --with capability:security --without capability:orchestration --dry-run', () => {+ const { execFileSync } = require('child_process');+ const scriptPath = path.join(__dirname, '..', '..', 'scripts', 'install-apply.js');+ const homeDir = fs.mkdtempSync(path.join(os.tmpdir(), 'selective-e2e-'));+ const projectDir = fs.mkdtempSync(path.join(os.tmpdir(), 'selective-e2e-project-'));++ try {+ const result = execFileSync('node', [+ scriptPath,+ '--profile', 'developer',+ '--with', 'capability:security',+ '--without', 'capability:orchestration',+ '--dry-run',+ ], {+ cwd: projectDir,+ env: { ...process.env, HOME: homeDir },+ encoding: 'utf8',+ stdio: ['pipe', 'pipe', 'pipe'],+ });++ assert.ok(result.includes('Mode: manifest'), 'Should be manifest mode');+ assert.ok(result.includes('Profile: developer'), 'Should show developer profile');+ assert.ok(result.includes('capability:security'), 'Should show included component');+ assert.ok(result.includes('capability:orchestration'), 'Should show excluded component');+ assert.ok(result.includes('security'), 'Selected modules should include security');+ } finally {+ fs.rmSync(homeDir, { recursive: true, force: true });+ fs.rmSync(projectDir, { recursive: true, force: true });+ }+ })) passed++; else failed++;++ if (test('end-to-end: --with lang:python --with agent:security-reviewer --dry-run', () => {+ const { execFileSync } = require('child_process');+ const scriptPath = path.join(__dirname, '..', '..', 'scripts', 'install-apply.js');+ const homeDir = fs.mkdtempSync(path.join(os.tmpdir(), 'selective-e2e-'));+ const projectDir = fs.mkdtempSync(path.join(os.tmpdir(), 'selective-e2e-project-'));++ try {+ const result = execFileSync('node', [+ scriptPath,+ '--with', 'lang:python',+ '--with', 'agent:security-reviewer',+ '--dry-run',+ ], {+ cwd: projectDir,+ env: { ...process.env, HOME: homeDir },+ encoding: 'utf8',+ stdio: ['pipe', 'pipe', 'pipe'],+ });++ assert.ok(result.includes('Mode: manifest'), 'Should be manifest mode');+ assert.ok(result.includes('lang:python'), 'Should show lang:python as included');+ assert.ok(result.includes('agent:security-reviewer'), 'Should show agent:security-reviewer as included');+ } finally {+ fs.rmSync(homeDir, { recursive: true, force: true });+ fs.rmSync(projectDir, { recursive: true, force: true });+ }+ })) passed++; else failed++;++ if (test('end-to-end: --with with unknown component fails cleanly', () => {+ const { execFileSync } = require('child_process');+ const scriptPath = path.join(__dirname, '..', '..', 'scripts', 'install-apply.js');++ let exitCode = 0;+ let stderr = '';+ try {+ execFileSync('node', [+ scriptPath,+ '--with', 'lang:nonexistent-language',+ '--dry-run',+ ], {+ encoding: 'utf8',+ stdio: ['pipe', 'pipe', 'pipe'],+ });+ } catch (error) {+ exitCode = error.status || 1;+ stderr = error.stderr || '';+ }++ assert.strictEqual(exitCode, 1, 'Should exit with error code 1');+ assert.ok(stderr.includes('Unknown install component'), 'Should report unknown component');+ })) passed++; else failed++;++ if (test('end-to-end: --without with unknown component fails cleanly', () => {+ const { execFileSync } = require('child_process');+ const scriptPath = path.join(__dirname, '..', '..', 'scripts', 'install-apply.js');++ let exitCode = 0;+ let stderr = '';+ try {+ execFileSync('node', [+ scriptPath,+ '--profile', 'core',+ '--without', 'capability:nonexistent',+ '--dry-run',+ ], {+ encoding: 'utf8',+ stdio: ['pipe', 'pipe', 'pipe'],+ });+ } catch (error) {+ exitCode = error.status || 1;+ stderr = error.stderr || '';+ }++ assert.strictEqual(exitCode, 1, 'Should exit with error code 1');+ assert.ok(stderr.includes('Unknown install component'), 'Should report unknown component');+ })) passed++; else failed++;++ // ─── End-to-End Actual Install ───++ if (test('end-to-end: installs --profile core --with capability:security and writes state', () => {+ const { execFileSync } = require('child_process');+ const scriptPath = path.join(__dirname, '..', '..', 'scripts', 'install-apply.js');+ const homeDir = fs.mkdtempSync(path.join(os.tmpdir(), 'selective-install-'));+ const projectDir = fs.mkdtempSync(path.join(os.tmpdir(), 'selective-install-project-'));++ try {+ const result = execFileSync('node', [+ scriptPath,+ '--profile', 'core',+ '--with', 'capability:security',+ ], {+ cwd: projectDir,+ env: { ...process.env, HOME: homeDir },+ encoding: 'utf8',+ stdio: ['pipe', 'pipe', 'pipe'],+ });++ const claudeRoot = path.join(homeDir, '.claude');+ // Security skill should be installed (from --with)+ assert.ok(fs.existsSync(path.join(claudeRoot, 'skills', 'security-review', 'SKILL.md')),+ 'Should install security-review skill from --with');+ // Core profile modules should be installed+ assert.ok(fs.existsSync(path.join(claudeRoot, 'rules', 'common', 'coding-style.md')),+ 'Should install core rules');++ // Install state should record include/exclude+ const statePath = path.join(claudeRoot, 'ecc', 'install-state.json');+ const state = JSON.parse(fs.readFileSync(statePath, 'utf8'));+ assert.strictEqual(state.request.profile, 'core');+ assert.deepStrictEqual(state.request.includeComponents, ['capability:security']);+ assert.deepStrictEqual(state.request.excludeComponents, []);+ assert.ok(state.resolution.selectedModules.includes('security'));+ } finally {+ fs.rmSync(homeDir, { recursive: true, force: true });+ fs.rmSync(projectDir, { recursive: true, force: true });+ }+ })) passed++; else failed++;++ if (test('end-to-end: installs --profile developer --without capability:orchestration and state reflects exclusion', () => {+ const { execFileSync } = require('child_process');+ const scriptPath = path.join(__dirname, '..', '..', 'scripts', 'install-apply.js');+ const homeDir = fs.mkdtempSync(path.join(os.tmpdir(), 'selective-install-'));+ const projectDir = fs.mkdtempSync(path.join(os.tmpdir(), 'selective-install-project-'));++ try {+ execFileSync('node', [+ scriptPath,+ '--profile', 'developer',+ '--without', 'capability:orchestration',+ ], {+ cwd: projectDir,+ env: { ...process.env, HOME: homeDir },+ encoding: 'utf8',+ stdio: ['pipe', 'pipe', 'pipe'],+ });++ const claudeRoot = path.join(homeDir, '.claude');+ // Orchestration skills should NOT be installed (from --without)+ assert.ok(!fs.existsSync(path.join(claudeRoot, 'skills', 'dmux-workflows', 'SKILL.md')),+ 'Should not install orchestration skills');+ // Developer profile base modules should be installed+ assert.ok(fs.existsSync(path.join(claudeRoot, 'rules', 'common', 'coding-style.md')),+ 'Should install core rules');+ assert.ok(fs.existsSync(path.join(claudeRoot, 'skills', 'tdd-workflow', 'SKILL.md')),+ 'Should install workflow skills');++ const statePath = path.join(claudeRoot, 'ecc', 'install-state.json');+ const state = JSON.parse(fs.readFileSync(statePath, 'utf8'));+ assert.strictEqual(state.request.profile, 'developer');+ assert.deepStrictEqual(state.request.excludeComponents, ['capability:orchestration']);+ assert.ok(!state.resolution.selectedModules.includes('orchestration'));+ } finally {+ fs.rmSync(homeDir, { recursive: true, force: true });+ fs.rmSync(projectDir, { recursive: true, force: true });+ }+ })) passed++; else failed++;++ if (test('end-to-end: --with alone (no profile) installs just the component modules', () => {+ const { execFileSync } = require('child_process');+ const scriptPath = path.join(__dirname, '..', '..', 'scripts', 'install-apply.js');+ const homeDir = fs.mkdtempSync(path.join(os.tmpdir(), 'selective-install-'));+ const projectDir = fs.mkdtempSync(path.join(os.tmpdir(), 'selective-install-project-'));++ try {+ execFileSync('node', [+ scriptPath,+ '--with', 'lang:typescript',+ ], {+ cwd: projectDir,+ env: { ...process.env, HOME: homeDir },+ encoding: 'utf8',+ stdio: ['pipe', 'pipe', 'pipe'],+ });++ const claudeRoot = path.join(homeDir, '.claude');+ // framework-language skill (from lang:typescript) should be installed+ assert.ok(fs.existsSync(path.join(claudeRoot, 'skills', 'coding-standards', 'SKILL.md')),+ 'Should install framework-language skills');+ // Its dependencies should be installed+ assert.ok(fs.existsSync(path.join(claudeRoot, 'rules', 'common', 'coding-style.md')),+ 'Should install dependency rules-core');++ const statePath = path.join(claudeRoot, 'ecc', 'install-state.json');+ const state = JSON.parse(fs.readFileSync(statePath, 'utf8'));+ assert.strictEqual(state.request.profile, null);+ assert.deepStrictEqual(state.request.includeComponents, ['lang:typescript']);+ assert.ok(state.resolution.selectedModules.includes('framework-language'));+ } finally {+ fs.rmSync(homeDir, { recursive: true, force: true });+ fs.rmSync(projectDir, { recursive: true, force: true });+ }+ })) passed++; else failed++;++ // ─── JSON output mode ───++ if (test('end-to-end: --dry-run --json includes component selections in output', () => {+ const { execFileSync } = require('child_process');+ const scriptPath = path.join(__dirname, '..', '..', 'scripts', 'install-apply.js');+ const homeDir = fs.mkdtempSync(path.join(os.tmpdir(), 'selective-e2e-'));+ const projectDir = fs.mkdtempSync(path.join(os.tmpdir(), 'selective-e2e-project-'));++ try {+ const output = execFileSync('node', [+ scriptPath,+ '--profile', 'core',+ '--with', 'capability:database',+ '--without', 'baseline:hooks',+ '--dry-run',+ '--json',+ ], {+ cwd: projectDir,+ env: { ...process.env, HOME: homeDir },+ encoding: 'utf8',+ stdio: ['pipe', 'pipe', 'pipe'],+ });++ const json = JSON.parse(output);+ assert.strictEqual(json.dryRun, true);+ assert.ok(json.plan, 'Should include plan object');+ assert.ok(+ json.plan.includedComponentIds.includes('capability:database'),+ 'JSON output should include capability:database in included components'+ );+ assert.ok(+ json.plan.excludedComponentIds.includes('baseline:hooks'),+ 'JSON output should include baseline:hooks in excluded components'+ );+ } finally {+ fs.rmSync(homeDir, { recursive: true, force: true });+ fs.rmSync(projectDir, { recursive: true, force: true });+ }+ })) passed++; else failed++;++ console.log(`\nResults: Passed: ${passed}, Failed: ${failed}`);+ process.exit(failed > 0 ? 1 : 0);+}++runTests();