@juangcarmona/lighthouse 0.5.0 → 0.7.0

package/src/lighthouse.mjs

@@ -6,6 +6,7 @@ import { createRequire } from 'node:module';
 import { basename, dirname, resolve } from 'node:path';
 import { execFileSync, spawnSync } from 'node:child_process';
 import { evaluateGuardrails, readGuardrailCatalog } from './guardrails.mjs';
+import { composeProfiles, normalizeApplication, profileCompositionResult, readProfileCatalog } from './profiles.mjs';
 let sdlcCapabilities;
 let sdlcReconcile;
 let sdlcGithub;
@@ -44,14 +45,20 @@ const managedPaths = [
 ];
 const profileManagedPaths = Object.freeze({
   'visual-theme': ['docs/design/DESIGN.md', '.agents/skills/lighthouse-ui/SKILL.md'],
+  'dotnet-backend': ['docs/profiles/dotnet/README.md', 'docs/profiles/dotnet/adoption.md', 'docs/profiles/dotnet/architecture.md', 'docs/profiles/dotnet/guardrails.md', 'docs/profiles/dotnet/practices.md', 'docs/profiles/dotnet/testing-and-development.md', 'docs/profiles/dotnet/use-cases.md', '.agents/skills/lighthouse-dotnet/SKILL.md'],
+  'react-web-platform': ['docs/profiles/react-web-platform/README.md', 'docs/profiles/react-web-platform/adoption.md', 'docs/profiles/react-web-platform/structure.md', 'docs/profiles/react-web-platform/guardrails.md', 'docs/profiles/react-web-platform/testing.md', '.agents/skills/lighthouse-react-web/SKILL.md'],
+  'web-bff': ['docs/profiles/web-bff/README.md', 'docs/profiles/web-bff/adoption.md', 'docs/profiles/web-bff/security.md', 'docs/profiles/web-bff/testing.md', '.agents/skills/lighthouse-web-bff/SKILL.md'],
+  'pwa-capability': ['docs/profiles/pwa-capability/README.md', 'docs/profiles/pwa-capability/adoption.md', 'docs/profiles/pwa-capability/guardrails.md', 'docs/profiles/pwa-capability/offline.md', 'docs/profiles/pwa-capability/testing.md', '.agents/skills/lighthouse-pwa/SKILL.md'],
+  'mobile-expo': ['docs/profiles/mobile-expo/README.md', 'docs/profiles/mobile-expo/adoption.md', 'docs/profiles/mobile-expo/guardrails.md', 'docs/profiles/mobile-expo/testing.md', '.agents/skills/lighthouse-mobile-expo/SKILL.md'],
+  'mobile-maui': ['docs/profiles/mobile-maui/README.md', 'docs/profiles/mobile-maui/adoption.md', 'docs/profiles/mobile-maui/guardrails.md', 'docs/profiles/mobile-maui/testing.md', '.agents/skills/lighthouse-mobile-maui/SKILL.md'],
 });
 const previousManagedPaths = managedPaths.slice(0, -1);
 const legacyManagedPaths = [projection];
-const supportedProfiles = ['node-tooling', 'dotnet-backend', 'visual-theme'];
+const supportedProfiles = readProfileCatalog().profiles.map(({ id }) => id);
 const branchPattern = '^(feat|fix|docs|refactor|test|chore|build|ci|perf|revert)/[1-9]\\d*-[a-z0-9]+(?:-[a-z0-9]+)*$';
 const authorityVersions = { productShape: '0.22.0', arcShape: '0.1.3' };
 const upgradeSchema = './node_modules/@juangcarmona/lighthouse/assets/schemas/lighthouse-upgrade.schema.json';
-const usage = 'Usage: lighthouse <init|authorities|reconcile|upgrade|capabilities|verify> [--name <product>] [--profile <profile>] [--scope <harness|sdlc|all>] [--format <text|json>] [--dry-run] [--apply]';
+const usage = 'Usage: lighthouse <init|create-dotnet|profiles|authorities|reconcile|upgrade|capabilities|verify> [--name <product>] [--profile <profile>] [--scope <harness|sdlc|all>] [--format <text|json>] [--dry-run] [--apply]';
 
 const defaultRepository = () => ({
   layout: [...layout],
@@ -77,15 +84,64 @@ function packageAsset(packageName, entry) {
 }
 
 function profileAssets(manifest) {
-  if (!(manifest?.profiles ?? []).includes('visual-theme')) return {};
-  try {
-    return {
-      'docs/design/DESIGN.md': packageAsset('@juangcarmona/lighthouse-ui', 'DESIGN.md'),
-      '.agents/skills/lighthouse-ui/SKILL.md': packageAsset('@juangcarmona/lighthouse-ui', 'skills/ui-design/SKILL.md'),
-    };
-  } catch (error) {
-    throw new Error(`Cannot read the installed Lighthouse UI profile: ${error.message}`);
+  const assets = {};
+  if ((manifest?.profiles ?? []).includes('visual-theme')) {
+    try {
+      assets['docs/design/DESIGN.md'] = packageAsset('@juangcarmona/lighthouse-ui', 'DESIGN.md');
+      assets['.agents/skills/lighthouse-ui/SKILL.md'] = packageAsset('@juangcarmona/lighthouse-ui', 'skills/ui-design/SKILL.md');
+    } catch (error) {
+      throw new Error(`Cannot read the installed Lighthouse UI profile: ${error.message}`);
+    }
+  }
+  if ((manifest?.profiles ?? []).includes('dotnet-backend')) {
+    const files = ['README.md', 'adoption.md', 'architecture.md', 'guardrails.md', 'practices.md', 'testing-and-development.md', 'use-cases.md', 'SKILL.md'];
+    for (const file of files) {
+      const target = file === 'SKILL.md' ? '.agents/skills/lighthouse-dotnet/SKILL.md' : `docs/profiles/dotnet/${file}`;
+      try { assets[target] = readFileSync(new URL(`../assets/profiles/dotnet/${file}`, import.meta.url), 'utf8'); }
+      catch (error) { throw new Error(`Cannot read the installed Lighthouse .NET profile: ${error.message}`); }
+    }
+  }
+  if ((manifest?.profiles ?? []).includes('react-web-platform')) {
+    const files = ['README.md', 'adoption.md', 'structure.md', 'guardrails.md', 'testing.md', 'SKILL.md'];
+    for (const file of files) {
+      const target = file === 'SKILL.md' ? '.agents/skills/lighthouse-react-web/SKILL.md' : `docs/profiles/react-web-platform/${file}`;
+      try { assets[target] = readFileSync(new URL(`../assets/profiles/react-web-platform/${file}`, import.meta.url), 'utf8'); }
+      catch (error) { throw new Error(`Cannot read the installed Lighthouse React web profile: ${error.message}`); }
+    }
+  }
+  if ((manifest?.profiles ?? []).includes('web-bff')) {
+    const files = ['README.md', 'adoption.md', 'security.md', 'testing.md', 'SKILL.md'];
+    for (const file of files) {
+      const target = file === 'SKILL.md' ? '.agents/skills/lighthouse-web-bff/SKILL.md' : `docs/profiles/web-bff/${file}`;
+      try { assets[target] = readFileSync(new URL(`../assets/profiles/web-bff/${file}`, import.meta.url), 'utf8'); }
+      catch (error) { throw new Error(`Cannot read the installed Lighthouse web BFF profile: ${error.message}`); }
+    }
+  }
+  if ((manifest?.profiles ?? []).includes('pwa-capability')) {
+    const files = ['README.md', 'adoption.md', 'guardrails.md', 'offline.md', 'testing.md', 'SKILL.md'];
+    for (const file of files) {
+      const target = file === 'SKILL.md' ? '.agents/skills/lighthouse-pwa/SKILL.md' : `docs/profiles/pwa-capability/${file}`;
+      try { assets[target] = readFileSync(new URL(`../assets/profiles/pwa-capability/${file}`, import.meta.url), 'utf8'); }
+      catch (error) { throw new Error(`Cannot read the installed Lighthouse PWA capability: ${error.message}`); }
+    }
   }
+  if ((manifest?.profiles ?? []).includes('mobile-expo')) {
+    const files = ['README.md', 'adoption.md', 'guardrails.md', 'testing.md', 'SKILL.md'];
+    for (const file of files) {
+      const target = file === 'SKILL.md' ? '.agents/skills/lighthouse-mobile-expo/SKILL.md' : `docs/profiles/mobile-expo/${file}`;
+      try { assets[target] = readFileSync(new URL(`../assets/profiles/mobile-expo/${file}`, import.meta.url), 'utf8'); }
+      catch (error) { throw new Error(`Cannot read the installed Lighthouse Expo mobile profile: ${error.message}`); }
+    }
+  }
+  if ((manifest?.profiles ?? []).includes('mobile-maui')) {
+    const files = ['README.md', 'adoption.md', 'guardrails.md', 'testing.md', 'SKILL.md'];
+    for (const file of files) {
+      const target = file === 'SKILL.md' ? '.agents/skills/lighthouse-mobile-maui/SKILL.md' : `docs/profiles/mobile-maui/${file}`;
+      try { assets[target] = readFileSync(new URL(`../assets/profiles/mobile-maui/${file}`, import.meta.url), 'utf8'); }
+      catch (error) { throw new Error(`Cannot read the installed Lighthouse .NET MAUI mobile profile: ${error.message}`); }
+    }
+  }
+  return assets;
 }
 
 function profileArguments(args) {
@@ -108,6 +164,7 @@ function defaultManifest(product, profiles = []) {
     schemaVersion: 1,
     baseline: '0.1.0',
     product,
+    application: { shape: 'unknown', stacks: [] },
     profiles: [...profiles],
     integrations: { productShape: null, arcShape: null },
     packages,
@@ -458,7 +515,7 @@ function printUpgradePlan(plan) {
 function validate(manifest) {
   const problems = [];
   if (!manifest || typeof manifest !== 'object' || Array.isArray(manifest)) return ['manifest must be an object'];
-  const allowed = ['$schema', 'schemaVersion', 'baseline', 'product', 'profiles', 'integrations', 'packages', 'managed', 'repository'];
+  const allowed = ['$schema', 'schemaVersion', 'baseline', 'product', 'application', 'profiles', 'integrations', 'packages', 'managed', 'repository'];
   for (const key of Object.keys(manifest)) if (!allowed.includes(key)) problems.push(`unknown field ${key}`);
   for (const key of ['schemaVersion', 'baseline', 'product', 'profiles', 'integrations', 'managed']) {
     if (!(key in manifest)) problems.push(`missing ${key}`);
@@ -469,6 +526,15 @@ function validate(manifest) {
   if (typeof manifest.product !== 'string' || !/^[A-Za-z0-9][A-Za-z0-9 ._-]{0,63}$/.test(manifest.product)) {
     problems.push('product must be a readable name of 1–64 characters');
   }
+  if ('application' in manifest) {
+    const application = manifest.application;
+    if (!application || typeof application !== 'object' || Array.isArray(application)
+        || !['unknown', 'frontend', 'backend', 'full-stack', 'service', 'library', 'tooling', 'cli', 'worker', 'mobile'].includes(application.shape)
+        || !Array.isArray(application.stacks) || application.stacks.some((stack) => typeof stack !== 'string' || !stack)
+        || new Set(application.stacks).size !== application.stacks.length) {
+      problems.push('application must declare a supported shape and unique stack names');
+    }
+  }
   const profiles = supportedProfiles;
   if (!Array.isArray(manifest.profiles) || manifest.profiles.some((p) => !profiles.includes(p))
       || new Set(manifest.profiles).size !== manifest.profiles.length) {
@@ -923,6 +989,11 @@ async function verify(manifest, format = 'text') {
     branch: gitBranch(),
     uiTokens: manifest?.profiles?.includes('visual-theme') ? packageAsset('@juangcarmona/lighthouse-ui', 'tokens.css') : null,
   });
+  const profileComposition = composeProfiles(readProfileCatalog(), manifest);
+  report.profiles = profileComposition;
+  const profileResult = profileCompositionResult(profileComposition);
+  report.results.push(profileResult);
+  report.summary[profileResult.status] = (report.summary[profileResult.status] ?? 0) + 1;
   const adoption = Object.values(capabilityAdoption(await readUpgradeState()));
   for (const item of adoption) {
     if (item.status !== 'adopted' || !item.recordPath || await exists(resolve(root, item.recordPath))) continue;
@@ -956,6 +1027,20 @@ async function verify(manifest, format = 'text') {
   console.log('Lighthouse manifest, repository boundaries and managed projection are valid.');
 }
 
+async function profiles(manifest, format = 'text') {
+  const composition = composeProfiles(readProfileCatalog(), manifest);
+  if (format === 'json') {
+    console.log(JSON.stringify(composition, null, 2));
+    if (composition.status === 'failed') process.exitCode = 1;
+    return;
+  }
+  console.log(`Lighthouse profile composition: ${composition.status}`);
+  console.log(`  application ${composition.application.shape}${composition.application.stacks.length ? ` (${composition.application.stacks.join(', ')})` : ''}`);
+  for (const profile of composition.selected) console.log(`  ${profile.id}: ${profile.status}${profile.nextAction ? `; next: ${profile.nextAction}` : ''}`);
+  if (!composition.selected.length) console.log('  no profiles selected');
+  if (composition.status === 'failed') process.exitCode = 1;
+}
+
 function planHash(plan) {
   const { authorization, ...payload } = plan;
   return contentHash(JSON.stringify(payload));
@@ -1117,6 +1202,11 @@ function formatFromArgs(args) {
 const args = process.argv.slice(2);
 const command = args[0];
 const commandArgs = args.slice(1);
+if (command === 'create-dotnet') {
+  process.argv.splice(2, 1);
+  await import('./create-dotnet.mjs');
+  process.exit(0);
+}
 let invalidArgument = false;
 for (let index = 0; index < commandArgs.length; index += 1) {
   const arg = commandArgs[index];
@@ -1135,12 +1225,12 @@ for (let index = 0; index < commandArgs.length; index += 1) {
     continue;
   }
   if (arg === '--format') {
-    if (!['verify', 'upgrade', 'capabilities'].includes(command) || !['text', 'json'].includes(commandArgs[index + 1])) invalidArgument = true;
+    if (!['profiles', 'verify', 'upgrade', 'capabilities'].includes(command) || !['text', 'json'].includes(commandArgs[index + 1])) invalidArgument = true;
     else index += 1;
     continue;
   }
   if (arg.startsWith('--format=') && ['text', 'json'].includes(arg.slice('--format='.length))) {
-    if (!['verify', 'upgrade', 'capabilities'].includes(command)) invalidArgument = true;
+    if (!['profiles', 'verify', 'upgrade', 'capabilities'].includes(command)) invalidArgument = true;
     continue;
   }
   if (arg === '--scope') {
@@ -1160,7 +1250,7 @@ for (let index = 0; index < commandArgs.length; index += 1) {
   if (['--id=', '--provider=', '--repo=', '--input=', '--plan-file=', '--authorize='].some((prefix) => arg.startsWith(prefix) && arg.length > prefix.length)) continue;
   invalidArgument = true;
 }
-if (!['init', 'authorities', 'reconcile', 'upgrade', 'capabilities', 'verify'].includes(command) || invalidArgument) {
+if (!['init', 'profiles', 'authorities', 'reconcile', 'upgrade', 'capabilities', 'verify'].includes(command) || invalidArgument) {
   console.error(usage);
   process.exit(2);
 }
@@ -1170,6 +1260,11 @@ try {
   else if (command === 'reconcile') await reconcile(args.slice(1));
   else if (command === 'upgrade') await upgrade(args.slice(1));
   else if (command === 'capabilities') await capabilities(args.slice(1));
+  else if (command === 'profiles') {
+    const manifest = await readManifest();
+    if (!manifest) throw new Error('Cannot read lighthouse.json: file does not exist; run lighthouse init --name <product>.');
+    await profiles(manifest, formatFromArgs(commandArgs));
+  }
   else {
     const manifest = await readManifest();
     if (!manifest) throw new Error('Cannot read lighthouse.json: file does not exist; run lighthouse init --name <product>.');

package/src/profiles.mjs

@@ -0,0 +1,206 @@
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+
+const catalogPath = fileURLToPath(new URL('../assets/profiles/catalog.json', import.meta.url));
+const allowedShapes = new Set(['unknown', 'frontend', 'backend', 'full-stack', 'service', 'library', 'tooling', 'cli', 'worker', 'mobile']);
+const allowedLevels = new Set(['required', 'recommended', 'optional']);
+const allowedKinds = new Set(['hard', 'soft']);
+const allowedVerification = new Set(['deterministic', 'semantic', 'human']);
+const allowedLayers = new Set(['static', 'unit', 'architecture', 'integration', 'functional', 'browser-e2e', 'operational']);
+const profileIdPattern = /^[a-z0-9]+(?:-[a-z0-9]+)*$/u;
+
+function stringArrayProblems(value, name, { required = false } = {}) {
+  if (!Array.isArray(value) || (required && value.length === 0) || value.some((item) => typeof item !== 'string' || !item)) {
+    return [`${name} must contain strings`];
+  }
+  return new Set(value).size === value.length ? [] : [`${name} must be unique`];
+}
+
+function profileReferenceProblems(value, name) {
+  return stringArrayProblems(value, name).concat((value ?? []).filter((id) => !profileIdPattern.test(id)).map((id) => `${name} contains invalid profile id ${id}`));
+}
+
+function guardrailProblems(guardrail) {
+  if (!guardrail || typeof guardrail !== 'object' || Array.isArray(guardrail)) return ['guardrail must be an object'];
+  const problems = [];
+  for (const key of ['id', 'level', 'kind', 'verification', 'command', 'description']) if (!(key in guardrail)) problems.push(`guardrail missing ${key}`);
+  if (typeof guardrail.id !== 'string' || !guardrail.id) problems.push('guardrail id must be a non-empty string');
+  if (!allowedLevels.has(guardrail.level)) problems.push(`guardrail ${guardrail.id} has an invalid level`);
+  if (!allowedKinds.has(guardrail.kind)) problems.push(`guardrail ${guardrail.id} has an invalid kind`);
+  if (!allowedVerification.has(guardrail.verification)) problems.push(`guardrail ${guardrail.id} has an invalid verification method`);
+  if (guardrail.command !== null && (typeof guardrail.command !== 'string' || !guardrail.command)) problems.push(`guardrail ${guardrail.id} command must be a string or null`);
+  if (typeof guardrail.description !== 'string' || !guardrail.description) problems.push(`guardrail ${guardrail.id} description must be a non-empty string`);
+  return problems;
+}
+
+function profileProblems(profile) {
+  const problems = [];
+  if (!profile || typeof profile !== 'object' || Array.isArray(profile)) return ['profile must be an object'];
+  for (const key of ['id', 'owner', 'purpose', 'appliesTo', 'surfaces', 'verification']) if (!(key in profile)) problems.push(`missing ${key}`);
+  if (typeof profile.id !== 'string' || !profileIdPattern.test(profile.id)) problems.push('id must use kebab-case');
+  if (typeof profile.owner !== 'string' || !profile.owner) problems.push('owner must be a non-empty string');
+  if (typeof profile.purpose !== 'string' || !profile.purpose) problems.push('purpose must be a non-empty string');
+  const applicability = profile.appliesTo;
+  if (!applicability || typeof applicability !== 'object' || Array.isArray(applicability)
+      || !Array.isArray(applicability.shapes) || !Array.isArray(applicability.stacks)
+      || applicability.shapes.length === 0 || applicability.shapes.some((shape) => typeof shape !== 'string' || !allowedShapes.has(shape))) {
+    problems.push('appliesTo must declare supported application shapes');
+  }
+  if (Array.isArray(applicability?.shapes) && new Set(applicability.shapes).size !== applicability.shapes.length) problems.push('appliesTo.shapes must be unique');
+  if (Array.isArray(applicability?.stacks) && (applicability.stacks.some((stack) => typeof stack !== 'string') || new Set(applicability.stacks).size !== applicability.stacks.length)) problems.push('appliesTo.stacks must contain unique strings');
+  if (!Array.isArray(profile.surfaces) || profile.surfaces.length === 0 || profile.surfaces.some((surface) => typeof surface !== 'string' || !surface)) problems.push('surfaces must contain non-empty strings');
+  for (const [name, value] of [['prerequisites', profile.prerequisites], ['libraries', profile.libraries], ['structure', profile.structure], ['commands', profile.commands], ['repairHints', profile.repairHints], ['exceptions', profile.exceptions]]) problems.push(...stringArrayProblems(value, name, { required: ['repairHints', 'exceptions'].includes(name)}));
+  for (const [name, value] of [['dependencies', profile.dependencies], ['incompatibleWith', profile.incompatibleWith]]) problems.push(...profileReferenceProblems(value, name));
+  if (typeof profile.failureConsequence !== 'string' || !profile.failureConsequence) problems.push('failureConsequence must be a non-empty string');
+  if (typeof profile.consumerFixture !== 'string' || !profile.consumerFixture) problems.push('consumerFixture must be a non-empty string');
+  if (typeof profile.upgradeStrategy !== 'string' || !profile.upgradeStrategy) problems.push('upgradeStrategy must be a non-empty string');
+  if (!Array.isArray(profile.guardrails) || profile.guardrails.length === 0) problems.push('guardrails must contain at least one guardrail');
+  const guardrailIds = new Set();
+  for (const guardrail of profile.guardrails ?? []) {
+    problems.push(...guardrailProblems(guardrail));
+    if (guardrail?.id && guardrailIds.has(guardrail.id)) problems.push(`duplicate guardrail ${guardrail.id}`);
+    if (guardrail?.id) guardrailIds.add(guardrail.id);
+  }
+  if (!Array.isArray(profile.combinations)) problems.push('combinations must be an array');
+  for (const combination of profile.combinations ?? []) {
+    if (!combination || typeof combination !== 'object' || Array.isArray(combination)) { problems.push('combination must be an object'); continue; }
+    if (!Array.isArray(combination.with) || combination.with.length === 0 || combination.with.some((id) => typeof id !== 'string' || !profileIdPattern.test(id))) problems.push('combination.with must contain profile ids');
+    if (typeof combination.purpose !== 'string' || !combination.purpose) problems.push('combination.purpose must be a non-empty string');
+  }
+  const layers = profile.verification?.layers;
+  if (!Array.isArray(layers) || layers.length === 0) problems.push('verification.layers must contain at least one layer');
+  const ids = new Set();
+  for (const layer of layers ?? []) {
+    if (!layer || typeof layer !== 'object' || Array.isArray(layer)) { problems.push('verification layer must be an object'); continue; }
+    for (const key of ['id', 'level', 'kind', 'verification']) if (!(key in layer)) problems.push(`verification layer missing ${key}`);
+    if (!allowedLayers.has(layer.id)) problems.push(`unsupported verification layer ${layer.id}`);
+    if (!allowedLevels.has(layer.level)) problems.push(`verification layer ${layer.id} has an invalid level`);
+    if (!allowedKinds.has(layer.kind)) problems.push(`verification layer ${layer.id} has an invalid kind`);
+    if (!allowedVerification.has(layer.verification)) problems.push(`verification layer ${layer.id} has an invalid verification method`);
+    if (layer.command !== undefined && layer.command !== null && (typeof layer.command !== 'string' || !layer.command)) problems.push(`verification layer ${layer.id} command must be a string or null`);
+    if (ids.has(layer.id)) problems.push(`duplicate verification layer ${layer.id}`);
+    ids.add(layer.id);
+  }
+  return problems;
+}
+
+function catalogProblems(catalog) {
+  if (!catalog || typeof catalog !== 'object' || Array.isArray(catalog)) return ['catalog must be an object'];
+  const problems = [];
+  if (catalog.schemaVersion !== 1) problems.push('schemaVersion must be 1');
+  if (!Array.isArray(catalog.profiles)) problems.push('profiles must be an array');
+  const ids = new Set();
+  for (const profile of catalog.profiles ?? []) {
+    problems.push(...profileProblems(profile).map((problem) => `${profile?.id ?? '<unknown>'}: ${problem}`));
+    if (profile?.id && ids.has(profile.id)) problems.push(`${profile.id}: duplicate id`);
+    if (profile?.id) ids.add(profile.id);
+  }
+  for (const profile of catalog.profiles ?? []) {
+    for (const reference of [...(profile.dependencies ?? []), ...(profile.incompatibleWith ?? []), ...(profile.combinations ?? []).flatMap((combination) => combination.with ?? [])]) {
+      if (!ids.has(reference)) problems.push(`${profile.id}: references undeclared profile ${reference}`);
+    }
+  }
+  return problems;
+}
+
+export function readProfileCatalog() {
+  const catalog = JSON.parse(readFileSync(catalogPath, 'utf8'));
+  const problems = catalogProblems(catalog);
+  if (problems.length) throw new Error(`Invalid profile catalog:\n${problems.join('\n')}`);
+  return catalog;
+}
+
+export function normalizeApplication(application) {
+  if (!application || typeof application !== 'object' || Array.isArray(application)) return { shape: 'unknown', stacks: [] };
+  return {
+    shape: typeof application.shape === 'string' ? application.shape : 'unknown',
+    stacks: Array.isArray(application.stacks) ? [...application.stacks] : [],
+  };
+}
+
+function profileStatus(profile, application) {
+  const shapeKnown = application.shape !== 'unknown';
+  const stacksKnown = application.stacks.length > 0;
+  const shapeMatches = !shapeKnown || profile.appliesTo.shapes.includes('any') || profile.appliesTo.shapes.includes(application.shape);
+  const stackMatches = !stacksKnown || profile.appliesTo.stacks.length === 0 || profile.appliesTo.stacks.includes('any') || application.stacks.some((stack) => profile.appliesTo.stacks.includes(stack));
+  if (!shapeMatches || !stackMatches) return 'failed';
+  if ((!shapeKnown && profile.appliesTo.shapes.length > 0) || (profile.appliesTo.stacks.length > 0 && !stacksKnown)) return 'unconfigured';
+  return 'passed';
+}
+
+function profileCompositionProblems(profile, selectedIds) {
+  const problems = [];
+  for (const dependency of profile.dependencies ?? []) if (!selectedIds.has(dependency)) problems.push(`${profile.id} requires the ${dependency} profile.`);
+  for (const incompatible of profile.incompatibleWith ?? []) if (selectedIds.has(incompatible)) problems.push(`${profile.id} is incompatible with the ${incompatible} profile.`);
+  return problems;
+}
+
+export function composeProfiles(catalog, manifest) {
+  const application = normalizeApplication(manifest?.application);
+  const selectedIds = new Set(manifest?.profiles ?? []);
+  const selected = (manifest?.profiles ?? []).map((id) => {
+    const profile = catalog.profiles.find((item) => item.id === id);
+    const status = profile ? profileStatus(profile, application) : 'failed';
+    const compositionProblems = profile ? profileCompositionProblems(profile, selectedIds) : [];
+    const problems = profile
+      ? status === 'failed'
+        ? [`${id} does not apply to application shape '${application.shape}' and stacks '${application.stacks.join(', ') || 'none'}'.`]
+        : status === 'unconfigured'
+          ? [`${id} needs application.shape and${profile.appliesTo.stacks.length ? ' application.stacks' : ''} in lighthouse.json.`]
+          : compositionProblems
+      : [`${id} is not declared by the installed profile catalog.`];
+    const effectiveStatus = status === 'failed' || compositionProblems.length ? 'failed' : status;
+    return {
+      id,
+      owner: profile?.owner ?? '@juangcarmona/lighthouse',
+      purpose: profile?.purpose ?? null,
+      appliesTo: profile?.appliesTo ?? null,
+      surfaces: profile?.surfaces ?? [],
+      prerequisites: profile?.prerequisites ?? [],
+      dependencies: profile?.dependencies ?? [],
+      incompatibleWith: profile?.incompatibleWith ?? [],
+      libraries: profile?.libraries ?? [],
+      structure: profile?.structure ?? [],
+      commands: profile?.commands ?? [],
+      guardrails: profile?.guardrails ?? [],
+      failureConsequence: profile?.failureConsequence ?? null,
+      repairHints: profile?.repairHints ?? [],
+      exceptions: profile?.exceptions ?? [],
+      combinations: profile?.combinations ?? [],
+      consumerFixture: profile?.consumerFixture ?? null,
+      upgradeStrategy: profile?.upgradeStrategy ?? null,
+      verification: profile?.verification ?? { layers: [] },
+      problems,
+      status: effectiveStatus,
+      nextAction: problems.length
+        ? status === 'unconfigured'
+          ? 'Declare application.shape and application.stacks, then run lighthouse profiles --format json.'
+          : compositionProblems.length
+            ? 'Select the required profiles or remove the incompatible selection, then rerun lighthouse profiles --format json.'
+            : 'Choose a compatible profile or correct application.shape and application.stacks.'
+        : null,
+    };
+  });
+  const status = selected.length === 0
+    ? 'not-applicable'
+    : selected.some((profile) => profile.status === 'failed')
+      ? 'failed'
+      : selected.some((profile) => profile.status === 'unconfigured')
+        ? 'unconfigured'
+        : 'passed';
+  return { schemaVersion: 1, application, selected, available: catalog.profiles.map((profile) => ({ ...profile })), status };
+}
+
+export function profileCompositionResult(composition) {
+  return {
+    id: 'foundation.profile-composition',
+    owner: '@juangcarmona/lighthouse',
+    level: 'recommended',
+    kind: 'hard',
+    verification: 'deterministic',
+    status: composition.status,
+    evidence: composition.selected.map((profile) => ({ id: profile.id, status: profile.status, layers: profile.verification.layers.map((layer) => layer.id) })),
+    problems: composition.selected.flatMap((profile) => profile.problems),
+    nextAction: composition.selected.find((profile) => profile.nextAction)?.nextAction ?? null,
+  };
+}

package/src/verify-dotnet.mjs

@@ -0,0 +1,85 @@
+import { spawnSync } from 'node:child_process';
+import { readdir, readFile, mkdir, mkdtemp, writeFile, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+
+const root = process.cwd();
+const nestedSolution = resolve(root, 'src/dotnet/Lighthouse.slnx');
+const rootSolutions = (await readdir(root)).filter((name) => name.endsWith('.slnx'));
+const solutionPath = await readFile(nestedSolution).then(() => nestedSolution).catch(() => {
+  if (rootSolutions.length !== 1) throw new Error('Expected src/dotnet/Lighthouse.slnx or one generated root solution.');
+  return resolve(root, rootSolutions[0]);
+});
+const dotnetRoot = dirname(solutionPath);
+const lighthouseSourceRoot = solutionPath === nestedSolution ? dotnetRoot : resolve(root, 'src/dotnet');
+const solutionName = solutionPath.slice(dotnetRoot.length + 1);
+function run(args, options = {}) {
+  const result = spawnSync('dotnet', args, { cwd: dotnetRoot, encoding: 'utf8', ...options });
+  if (result.error) throw result.error;
+  return result;
+}
+for (const args of [
+  ['restore', solutionName, '--locked-mode'],
+  ['build', solutionName, '--no-restore', '-c', 'Release'],
+  ['test', solutionName, '--no-build', '--no-restore', '-c', 'Release']
+]) {
+  const result = run(args, { stdio: 'inherit' });
+  if (result.status !== 0) process.exit(result.status ?? 1);
+}
+
+const sourceFiles = [];
+async function collectSource(folder) {
+  for (const entry of await readdir(resolve(dotnetRoot, folder), { withFileTypes: true })) {
+    if (['bin', 'obj', 'node_modules'].includes(entry.name)) continue;
+    const path = folder === '.' ? entry.name : `${folder}/${entry.name}`;
+    if (entry.isDirectory()) await collectSource(path);
+    else if (entry.isFile() && entry.name.endsWith('.cs')) sourceFiles.push(path);
+  }
+}
+await collectSource('.');
+const formatted = run(['format', 'whitespace', '.', '--folder', '--verify-no-changes',
+  '--include', ...sourceFiles, '--verbosity', 'quiet'], { stdio: 'inherit' });
+if (formatted.status !== 0) process.exit(formatted.status ?? 1);
+
+const solution = await readFile(solutionPath, 'utf8');
+for (const match of solution.matchAll(/<Project Path="([^"]+\.csproj)"/g)) {
+  const result = run(['msbuild', resolve(dotnetRoot, match[1]), '-getProperty:AssemblyName,LighthouseModule', '-getItem:ProjectReference']);
+  if (result.status !== 0) throw new Error(`Cannot evaluate project policy: ${match[1]}`);
+  const evaluated = JSON.parse(result.stdout);
+  const assembly = evaluated.Properties.AssemblyName;
+  if (!assembly.includes('.Modules.') || assembly.endsWith('.Contracts') || assembly.endsWith('Tests')) continue;
+  const active = evaluated.Properties.LighthouseModule === 'true';
+  const attached = evaluated.Items.ProjectReference.some((item) => item.Identity.endsWith('Lighthouse.Analyzers.csproj')
+    && item.OutputItemType === 'Analyzer' && item.ReferenceOutputAssembly === 'false');
+  if (!active || !attached) throw new Error(`Module ${assembly} must activate and reference the Lighthouse analyzer.`);
+}
+process.stdout.write('Every implementation module in the solution activates the analyzer.\n');
+
+const probe = await mkdtemp(join(tmpdir(), 'lighthouse-rejection-'));
+const xml = (value) => value.replaceAll('&', '&amp;').replaceAll('"', '&quot;').replaceAll('<', '&lt;');
+try {
+  await mkdir(resolve(probe, 'Sibling'));
+  await mkdir(resolve(probe, 'Invalid'));
+  await writeFile(resolve(probe, 'Sibling/Sibling.csproj'), '<Project Sdk="Microsoft.NET.Sdk"><PropertyGroup><TargetFramework>net10.0</TargetFramework><ImplicitUsings>enable</ImplicitUsings><AssemblyName>JuanGCarmona.Probe.Modules.Sibling</AssemblyName></PropertyGroup></Project>');
+  await writeFile(resolve(probe, 'Sibling/Sibling.cs'), 'namespace JuanGCarmona.Probe.Modules.Sibling; public sealed class SiblingExport {}');
+  await writeFile(resolve(probe, 'Invalid/Invalid.csproj'), `<Project Sdk="Microsoft.NET.Sdk">
+    <PropertyGroup><TargetFramework>net10.0</TargetFramework><ImplicitUsings>enable</ImplicitUsings><AssemblyName>JuanGCarmona.Probe.Modules.Invalid</AssemblyName><LighthouseModule>true</LighthouseModule></PropertyGroup>
+    <ItemGroup>
+      <CompilerVisibleProperty Include="LighthouseModule" />
+      <ProjectReference Include="../Sibling/Sibling.csproj" />
+      <ProjectReference Include="${xml(resolve(lighthouseSourceRoot, 'Lighthouse.Cqrs/Lighthouse.Cqrs.csproj'))}" />
+      <ProjectReference Include="${xml(resolve(lighthouseSourceRoot, 'Lighthouse.Analyzers/Lighthouse.Analyzers.csproj'))}" OutputItemType="Analyzer" ReferenceOutputAssembly="false" />
+    </ItemGroup></Project>`);
+  await writeFile(resolve(probe, 'Invalid/Invalid.cs'), `using JuanGCarmona.Lighthouse.Cqrs;
+    namespace JuanGCarmona.Probe.Modules.Invalid;
+    public class ExposedHandler : ICommandHandler<string, string> {
+      public Task<string> Handle(string request, CancellationToken token) => Task.FromResult(request);
+    }`);
+  const result = run(['build', resolve(probe, 'Invalid/Invalid.csproj'), '-c', 'Release']);
+  const output = result.stdout + result.stderr;
+  if (result.status === 0 || !/error LH1001\b/.test(output) || !/error LH1002\b/.test(output)) {
+    process.stderr.write(output);
+    throw new Error('The real build must reject both the exposed handler and sibling implementation reference.');
+  }
+  process.stdout.write('Build rejection rehearsal passed: LH1001 and LH1002 blocked the invalid module.\n');
+} finally { await rm(probe, { recursive: true, force: true }); }