bmad-plus 0.12.2 → 0.14.0

package/tools/build/generate.js

@@ -3,17 +3,19 @@
  * BMAD+ Build — registry.yaml → pack artifacts generator (Pillar 1)
  *
  * Reads the root registry.yaml (the single source of truth) and generates the
- * pack data currently hand-maintained in tools/cli/lib/packs.js:
+ * pack data in tools/cli/lib/packs.js and src/bmad-plus/module.yaml:
  *   - PACKS            (CLI pack definitions)
  *   - PACK_ORDER       (install/display order)
  *   - EXPECTED_AGENTS  (what `bmad-plus doctor` verifies after install)
+ *   - DERIVED          (counts, display metadata, targets, Python provisioning)
  *
  * Usage:
  *   node tools/build/generate.js              # print generated packs module source
- *   node tools/build/generate.js --json       # print { PACKS, PACK_ORDER, EXPECTED_AGENTS } as JSON
+ *   node tools/build/generate.js --json       # print all generated data as JSON
  *   node tools/build/generate.js --out <file> # write generated module source to <file>
+ *     --module-out <yaml>                     # also write generated module.yaml
  *   node tools/build/generate.js --check      # verify registry.yaml reproduces the live
- *                                             # tools/cli/lib/packs.js exactly (exit 1 on drift)
+ *                                             # packs.js and module.yaml (exit 1 on drift)
  *
  * Author: Laurent Rochetta
  */
@@ -28,9 +30,65 @@ const yaml = require('js-yaml');
 const REPO_ROOT = path.join(__dirname, '..', '..');
 const DEFAULT_REGISTRY_PATH = path.join(REPO_ROOT, 'registry.yaml');
 const DEFAULT_PACKS_MODULE_PATH = path.join(REPO_ROOT, 'tools', 'cli', 'lib', 'packs.js');
+const DEFAULT_MODULE_PATH = path.join(REPO_ROOT, 'src', 'bmad-plus', 'module.yaml');
+const MODULE_TEMPLATE_PATH = path.join(__dirname, 'module.template.yaml');
 const PACKAGE_JSON_PATH = path.join(REPO_ROOT, 'package.json');
 
 const INSTALL_LAYOUTS = ['loose', 'packaged'];
+const OWNED_COUNT_RE =
+  /(?<![\w.-])\d+\+?[\s-]+(?:[A-Za-zÀ-ÿ-]+\s+){0,6}(?:agents?|skills?|workflows?|packs?|frameworks?|languages?|reference files)\b/gi;
+const STANDARD_PREFIX_RE =
+  /\b(?:ISO(?:\/IEC)?|IEC|SOC|NIST(?: SP)?|PCI(?: DSS)?|WCAG|Section)\s*$/i;
+
+function hasOwnedCount(value) {
+  return [...value.matchAll(OWNED_COUNT_RE)].some(
+    (match) => !STANDARD_PREFIX_RE.test(value.slice(0, match.index))
+  );
+}
+
+function assertResourcePath(file, where) {
+  if (
+    typeof file !== 'string' ||
+    !file ||
+    /[\\:\0]/.test(file) ||
+    file.split('/').some((part) => !part || part === '.' || part === '..')
+  ) {
+    throw new Error(`${where}: required resource must be a portable relative file path`);
+  }
+}
+
+/** Installed entry points, derived from the same layout used by pack-copy.js. */
+function buildRequiredResources(pack) {
+  const where = `registry.yaml: pack "${pack.pack_dir}"`;
+  for (const file of [
+    ...pack.agents,
+    ...(pack.skills || []),
+    ...(pack.data || []),
+    ...((pack.doctor || {}).pack_agents || []),
+    ...((pack.doctor || {}).required_resources || []),
+    ...(pack.python_entry ? [pack.python_entry] : []),
+  ]) {
+    assertResourcePath(file, where);
+  }
+  const resources = [];
+  if (pack.install_layout === 'loose') {
+    resources.push(...pack.agents.map((id) => `.agents/skills/${id}/SKILL.md`));
+  } else {
+    resources.push(
+      ...pack.doctor.pack_agents.map((file) => `.agents/skills/${pack.pack_dir}/${file}`)
+    );
+  }
+  resources.push(...(pack.skills || []).map((id) => `.agents/skills/${id}/SKILL.md`));
+  resources.push(...(pack.data || []).map((file) => `.agents/data/${file}`));
+  resources.push(
+    ...((pack.doctor || {}).required_resources || []).map(
+      (file) => `.agents/skills/${pack.pack_dir}/${file}`
+    )
+  );
+  if (pack.python_entry) resources.push(`.agents/skills/${pack.pack_dir}/${pack.python_entry}`);
+  for (const file of resources) assertResourcePath(file, where);
+  return [...new Set(resources)];
+}
 
 /**
  * Validate the minimal contract the generator relies on.
@@ -53,11 +111,26 @@ function validateRegistry(registry) {
     seenOrders.add(pack.order);
 
     if (!pack.cli || typeof pack.cli !== 'object') throw new Error(`${where}: missing "cli" block`);
-    for (const field of ['name', 'icon', 'desc']) {
+    for (const field of ['name', 'icon']) {
       if (typeof pack.cli[field] !== 'string' || pack.cli[field] === '') {
         throw new Error(`${where}: missing cli.${field}`);
       }
     }
+    if (!pack.cli.desc && !pack.cli.desc_template) {
+      throw new Error(`${where}: missing cli.desc or cli.desc_template`);
+    }
+    for (const [field, value] of Object.entries({
+      'cli.desc': pack.cli.desc,
+      'cli.desc_template': pack.cli.desc_template,
+      summary: pack.summary,
+      summary_template: pack.summary_template,
+    })) {
+      if (value !== undefined && (typeof value !== 'string' || hasOwnedCount(value))) {
+        throw new Error(
+          `${where}: ${field} must use derived placeholders for owned count dimensions`
+        );
+      }
+    }
     if (!Array.isArray(pack.agents)) throw new Error(`${where}: "agents" must be a list`);
     if (pack.skills !== undefined && !Array.isArray(pack.skills)) {
       throw new Error(`${where}: "skills" must be a list`);
@@ -71,6 +144,66 @@ function validateRegistry(registry) {
     if (pack.install_layout === 'packaged' && !Array.isArray((pack.doctor || {}).pack_agents)) {
       throw new Error(`${where}: packaged layout requires "doctor.pack_agents" list`);
     }
+    if (
+      pack.doctor?.required_resources !== undefined &&
+      !Array.isArray(pack.doctor.required_resources)
+    ) {
+      throw new Error(`${where}: doctor.required_resources must be a list`);
+    }
+    if (
+      !Array.isArray(pack.runtime) ||
+      pack.runtime.length === 0 ||
+      pack.runtime.some((runtime) => !Object.hasOwn(registry.runtimes || {}, runtime))
+    ) {
+      throw new Error(`${where}: runtime must declare known runtimes`);
+    }
+    buildRequiredResources(pack);
+    if (pack.personas !== undefined) {
+      if (!Array.isArray(pack.personas)) throw new Error(`${where}: personas must be a list`);
+      const roster = new Set([...pack.agents, ...(pack.sub_agents || [])]);
+      const ids = new Set();
+      for (const persona of pack.personas) {
+        if (
+          !persona ||
+          ['id', 'name', 'role', 'description'].some(
+            (key) => typeof persona[key] !== 'string' || !persona[key].trim()
+          )
+        ) {
+          throw new Error(`${where}: each persona needs id, name, role and description`);
+        }
+        if (!roster.has(persona.id) || ids.has(persona.id)) {
+          throw new Error(
+            `${where}: persona ${persona.id} is absent from its roster or duplicated`
+          );
+        }
+        ids.add(persona.id);
+      }
+    }
+  }
+  const integration = registry.targets?.integration;
+  if (
+    integration?.execution !== 'host-managed' ||
+    integration?.lifecycle_events !== 'not-integrated'
+  ) {
+    throw new Error(
+      'registry.yaml: targets.integration must declare the delivered instruction integration'
+    );
+  }
+  for (const [runtime, config] of Object.entries(registry.runtimes || {})) {
+    if (
+      typeof config?.min_version !== 'string' ||
+      !/^\d+\.\d+(?:\.\d+)?$/.test(config.min_version)
+    ) {
+      throw new Error(`registry.yaml: runtime "${runtime}" needs a numeric min_version`);
+    }
+  }
+  const tools = new Set();
+  for (const adapter of registry.targets.adapters || []) {
+    if (!adapter || typeof adapter.tool !== 'string' || !adapter.tool || tools.has(adapter.tool)) {
+      throw new Error('registry.yaml: adapter tool names must be nonempty and unique');
+    }
+    tools.add(adapter.tool);
+    assertResourcePath(adapter.file, `registry.yaml: adapter "${adapter.tool}"`);
   }
   return registry;
 }
@@ -99,6 +232,7 @@ function buildPackOrder(registry) {
  *   - `required`        only when true (other packs omit the key entirely)
  */
 function buildPacks(registry) {
+  const derived = buildDerived(registry);
   const packs = {};
   for (const [id, p] of sortedPackEntries(registry)) {
     const entry = {
@@ -112,12 +246,192 @@ function buildPacks(registry) {
     entry.packDir = p.pack_dir;
     entry.packSrcDir = p.pack_src_dir || 'packs';
     if (p.required === true) entry.required = true;
-    entry.desc = p.cli.desc;
+    entry.desc = derived.packs[id].desc;
     packs[id] = entry;
   }
   return packs;
 }
 
+/** Recursively count reference files; sourceRoot is injectable for fixture trees. */
+function countMarkdownFiles(dir) {
+  if (!fs.existsSync(dir)) return 0;
+  return fs.readdirSync(dir, { withFileTypes: true }).reduce((count, entry) => {
+    if (entry.isDirectory()) return count + countMarkdownFiles(path.join(dir, entry.name));
+    return count + Number(entry.isFile() && entry.name.endsWith('.md'));
+  }, 0);
+}
+
+function renderSummary(pack, derived, field = 'summary') {
+  const template = field === 'summary' ? pack.summary_template : pack.cli.desc_template;
+  const fallback = field === 'summary' ? pack.summary : pack.cli.desc;
+  if (!template) return fallback || '';
+  const values = {
+    agent_count: derived.agentCount,
+    installer_agent_count: derived.installerAgentCount,
+    sub_agent_count: derived.subAgentCount,
+    workflow_count: derived.workflowCount,
+    framework_count: derived.frameworkCount,
+    category_count: derived.categoryCount,
+    skill_count: derived.skillCount,
+    reference_file_count: derived.referenceFiles,
+  };
+  return template.replace(/\{([a-z_]+)\}/g, (_match, key) => {
+    if (!(key in values)) throw new Error(`Unknown derived summary placeholder: ${key}`);
+    return String(values[key]);
+  });
+}
+
+/** The one derivation engine; its JSON result is shipped for runtime consumers. */
+function buildDerived(registry, { sourceRoot = path.join(REPO_ROOT, 'src', 'bmad-plus') } = {}) {
+  const packs = {};
+  const pythonPacks = {};
+  let installerAgents = 0;
+  let totalAgents = 0;
+  for (const [id, pack] of sortedPackEntries(registry)) {
+    const categories = pack.categories || [];
+    const categoryAgentCounts = categories.map((category) => (category.agents || []).length);
+    const categoryAgentCount = categoryAgentCounts.reduce((sum, count) => sum + count, 0);
+    const installerAgentCount = pack.agents.length;
+    const subAgentCount = (pack.sub_agents || []).length;
+    const facts = {
+      id,
+      order: pack.order,
+      name: pack.cli.name,
+      displayName: pack.display_name || pack.cli.name,
+      required: pack.required === true,
+      installerAgentCount,
+      categoryAgentCount,
+      agentCount: categoryAgentCount || subAgentCount || installerAgentCount,
+      subAgentCount,
+      workflowCount:
+        (pack.workflows || []).length +
+        categories.reduce((sum, c) => sum + (c.workflows || []).length, 0),
+      frameworkCount: (pack.compliance_tags || []).length,
+      categoryCount: categories.length,
+      skillCount: (pack.skills || []).length,
+      referenceFiles: countMarkdownFiles(
+        path.join(sourceRoot, pack.pack_src_dir || 'packs', pack.pack_dir, 'references')
+      ),
+      categoryAgentCounts,
+      runtimes: [...pack.runtime],
+      requiredResources: buildRequiredResources(pack),
+      personas: (pack.personas || []).map(({ id, name, role, description, alias }) => ({
+        id,
+        name,
+        role,
+        description,
+        ...(alias ? { alias } : {}),
+      })),
+    };
+    facts.summary = renderSummary(pack, facts);
+    facts.desc = renderSummary(pack, facts, 'description');
+    facts.description = facts.desc;
+    packs[id] = facts;
+    installerAgents += installerAgentCount;
+    totalAgents += new Set([
+      ...pack.agents,
+      ...(pack.sub_agents || []),
+      ...categories.flatMap((c) => c.agents || []),
+    ]).size;
+    if ((pack.runtime || []).includes('python')) {
+      const packagePath =
+        pack.python_package || `src/bmad-plus/${pack.pack_src_dir || 'packs'}/${pack.pack_dir}`;
+      pythonPacks[id] = {
+        requirements: [...packagePath.split(/[\\/]/), 'requirements.txt'],
+        verifyModules: [...(pack.python_verify_modules || [])],
+      };
+    }
+  }
+  const { LANGUAGES } = require('../cli/i18n');
+  return {
+    product: {
+      code: registry.product.code,
+      displayName: registry.product.display_name,
+      version: registry.product.version,
+      derivedFrom: registry.product.derived_from,
+    },
+    packOrder: buildPackOrder(registry),
+    packCount: Object.keys(packs).length,
+    installerAgents,
+    totalAgents,
+    languages: Object.keys(LANGUAGES),
+    packs,
+    pythonPacks,
+    diagnostics: {
+      schemaVersion: 1,
+      runtimeMinimums: Object.fromEntries(
+        Object.entries(registry.runtimes).map(([id, runtime]) => [id, runtime.min_version])
+      ),
+      integrations: Object.fromEntries(
+        registry.targets.adapters.map(({ tool, file }) => [
+          tool,
+          {
+            instructionFile: file,
+            execution: registry.targets.integration.execution,
+            lifecycleEvents: registry.targets.integration.lifecycle_events,
+          },
+        ])
+      ),
+    },
+    targets: {
+      spine: registry.targets.spine,
+      adapters: registry.targets.adapters.map(({ tool, file }) => ({ tool, file })),
+      models_supported: [...registry.targets.models_supported],
+    },
+  };
+}
+
+/** Preserve project questions/compatibility separately from generated pack facts. */
+function generateModuleSource(registry, templatePath = MODULE_TEMPLATE_PATH) {
+  const moduleConfig = yaml.load(fs.readFileSync(templatePath, 'utf8'));
+  const derived = buildDerived(registry);
+  moduleConfig.code = registry.product.code;
+  moduleConfig.packs = {};
+  for (const [id, pack] of sortedPackEntries(registry)) {
+    const facts = derived.packs[id];
+    const entry = {
+      name: facts.displayName,
+      icon: pack.icon_emoji,
+      description: facts.summary || facts.desc,
+      required: facts.required,
+      agents: [...pack.agents],
+      skills: [...(pack.skills || [])],
+    };
+    for (const key of [
+      'data',
+      'external_package',
+      'orchestrator',
+      'categories',
+      'workflows',
+      'sub_agents',
+      'required_keys',
+      'optional_keys',
+      'cohabitation_warning',
+    ]) {
+      if (key in pack) entry[key] = JSON.parse(JSON.stringify(pack[key]));
+    }
+    if (pack.install_layout === 'packaged') {
+      entry.packDir = pack.pack_dir;
+      entry.packSrcDir = pack.pack_src_dir || 'packs';
+    }
+    moduleConfig.packs[id] = entry;
+  }
+  moduleConfig.install_packs['multi-select'] = [
+    ...derived.packOrder
+      .filter((id) => !derived.packs[id].required)
+      .map((id) => ({
+        value: id,
+        label: `${registry.packs[id].icon_emoji} ${derived.packs[id].displayName} — ${derived.packs[id].summary || derived.packs[id].desc}`,
+      })),
+    { value: 'all', label: 'Tout installer' },
+    { value: 'none', label: 'Aucun — Core uniquement' },
+  ];
+  return (
+    '# AUTO-GENERATED from registry.yaml + tools/build/module.template.yaml — DO NOT EDIT.\n' +
+    yaml.dump(moduleConfig, { lineWidth: 110, noRefs: true })
+  );
+}
+
 /**
  * Generate EXPECTED_AGENTS (consumed by `bmad-plus doctor`).
  *   - loose    packs → agent DIRECTORIES checked under .agents/skills/
@@ -135,12 +449,13 @@ function buildExpectedAgents(registry) {
   return expected;
 }
 
-/** Convenience: all three artifacts at once. */
+/** Convenience: all runtime artifacts at once. */
 function buildAll(registry) {
   return {
     PACKS: buildPacks(registry),
     PACK_ORDER: buildPackOrder(registry),
     EXPECTED_AGENTS: buildExpectedAgents(registry),
+    DERIVED: buildDerived(registry),
   };
 }
 
@@ -149,7 +464,7 @@ function buildAll(registry) {
  * Evaluating this source yields exports deep-equal to the hand-written module.
  */
 function generatePacksModuleSource(registry) {
-  const { PACKS, PACK_ORDER, EXPECTED_AGENTS } = buildAll(registry);
+  const { PACKS, PACK_ORDER, EXPECTED_AGENTS, DERIVED } = buildAll(registry);
   const j = (value) => JSON.stringify(value, null, 2);
   return [
     '/**',
@@ -166,13 +481,17 @@ function generatePacksModuleSource(registry) {
     '',
     `const EXPECTED_AGENTS = ${j(EXPECTED_AGENTS)};`,
     '',
-    'module.exports = { PACKS, PACK_ORDER, EXPECTED_AGENTS };',
+    `const DERIVED = ${j(DERIVED)};`,
+    '',
+    'module.exports = { PACKS, PACK_ORDER, EXPECTED_AGENTS, DERIVED };',
     '',
   ].join('\n');
 }
 
 /** Human-readable drill-down for a mismatching keyed object. */
 function describeDiff(label, generated, current, mismatches) {
+  generated = generated || {};
+  current = current || {};
   if (Array.isArray(generated) || Array.isArray(current)) {
     mismatches.push(
       `${label}: generated ${JSON.stringify(generated)} != current ${JSON.stringify(current)}`
@@ -202,13 +521,25 @@ function check({
   registryPath = DEFAULT_REGISTRY_PATH,
   packsModulePath = DEFAULT_PACKS_MODULE_PATH,
   packageJsonPath = PACKAGE_JSON_PATH,
+  modulePath = DEFAULT_MODULE_PATH,
 } = {}) {
   const registry = loadRegistry(registryPath);
+  delete require.cache[require.resolve(packsModulePath)];
   const current = require(packsModulePath);
   const generated = buildAll(registry);
   const mismatches = [];
 
   const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+  const { checkPythonDelivery } = require('./pack-delivery');
+  mismatches.push(...checkPythonDelivery(registry, { packageRoot: REPO_ROOT, packageJson: pkg }));
+  try {
+    require('../cli/lib/studio').validatePack(
+      path.join(REPO_ROOT, 'src/bmad-plus/packs/pack-dev-studio'),
+      registry.packs['dev-studio']
+    );
+  } catch (error) {
+    mismatches.push('Dev Studio: ' + error.message);
+  }
   if (!registry.product || registry.product.version !== pkg.version) {
     const declared = registry.product ? registry.product.version : undefined;
     mismatches.push(
@@ -216,11 +547,16 @@ function check({
     );
   }
 
-  for (const key of ['PACKS', 'PACK_ORDER', 'EXPECTED_AGENTS']) {
+  for (const key of ['PACKS', 'PACK_ORDER', 'EXPECTED_AGENTS', 'DERIVED']) {
     if (!isDeepStrictEqual(generated[key], current[key])) {
       describeDiff(key, generated[key], current[key], mismatches);
     }
   }
+  if (
+    fs.readFileSync(modulePath, 'utf8').replace(/\r\n/g, '\n') !== generateModuleSource(registry)
+  ) {
+    mismatches.push('module.yaml: generated pack metadata differs from registry.yaml');
+  }
 
   return { ok: mismatches.length === 0, mismatches };
 }
@@ -233,7 +569,7 @@ function main(argv) {
   if (args.includes('--check')) {
     const result = check();
     if (result.ok) {
-      console.log('OK — registry.yaml reproduces tools/cli/lib/packs.js exactly (no drift).');
+      console.log('OK — registry.yaml reproduces packs.js and module.yaml (no drift).');
       return 0;
     }
     console.error('DRIFT DETECTED between registry.yaml and tools/cli/lib/packs.js:');
@@ -257,6 +593,15 @@ function main(argv) {
       return 1;
     }
     fs.writeFileSync(path.resolve(outPath), source, 'utf8');
+    const moduleOutIdx = args.indexOf('--module-out');
+    if (moduleOutIdx !== -1) {
+      if (!args[moduleOutIdx + 1]) throw new Error('--module-out requires a file path');
+      fs.writeFileSync(
+        path.resolve(args[moduleOutIdx + 1]),
+        generateModuleSource(registry),
+        'utf8'
+      );
+    }
     console.log(`Generated ${path.resolve(outPath)} from registry.yaml`);
     return 0;
   }
@@ -265,20 +610,25 @@ function main(argv) {
   return 0;
 }
 
-if (require.main === module) {
-  process.exitCode = main(process.argv);
-}
-
 module.exports = {
   DEFAULT_REGISTRY_PATH,
   DEFAULT_PACKS_MODULE_PATH,
+  DEFAULT_MODULE_PATH,
+  MODULE_TEMPLATE_PATH,
   loadRegistry,
   validateRegistry,
   buildPacks,
   buildPackOrder,
   buildExpectedAgents,
   buildAll,
+  buildDerived,
+  renderSummary,
+  generateModuleSource,
   generatePacksModuleSource,
   check,
   main,
 };
+
+if (require.main === module) {
+  process.exitCode = main(process.argv);
+}

package/tools/build/generated-adapters/.codex/AGENTS.md

@@ -28,16 +28,21 @@ To activate an agent, say its name or persona:
 - **Forge** (Architect-Dev) — Architecture + Development + Documentation
 - **Sentinel** (Quality) — QA + UX review
 - **Nexus** (Orchestrator) — Sprint management + Autopilot + Parallel execution
-- **Shadow** (OSINT) — Investigation + Scraping + Psychoprofiling (if OSINT pack installed)
-- **Maker** (Agent Creator) — Design, build, validate, and package new BMAD+ agents
-- **Shield** (GRC) — Compliance agents for GDPR, ISO 27001, SOC 2, HIPAA, EU AI Act, DORA, NIS2 and more (derived counts: see Registry facts below)
+- **Shadow** (OSINT) — Investigation + Scraping + Psychoprofiling (OSINT)
+- **Maker** (Agent Creator) — Design, build, validate, and package new BMAD+ agents (Maker)
+- **Shield** (GRC) — Compliance agents for GDPR, ISO 27001, SOC 2, HIPAA, EU AI Act, DORA, NIS2 and more (Shield)
+- **SEO Scout** (Technical Scanner) — Crawling + technical inspection + performance (SEO)
+- **SEO Chief** (Strategist & Reporter) — Scoring + strategy + reporting (SEO)
+- **SEO Judge** (Content & AI Analyst) — Content quality + structured data + GEO analysis (SEO)
+- **Zecher** (זכר, Memory Guardian) — Memory Archivist — Persistent cross-session memory, consolidation, project scanning, context recall, session handoffs (Memory)
 - **Miriam** (מרים) — Business Analyst — Strategic analysis, research, product briefs (Dev Studio)
 - **Huldah** (חולדה) — Technical Writer — Documentation, diagrams, editorial review (Dev Studio)
 - **Yosef** (יוסף) — Product Manager — PRD, requirements, feature prioritization (Dev Studio)
 - **Rachel** (רחל) — UX Designer — User experience, wireframes, empathy mapping (Dev Studio)
 - **Bezalel** (בצלאל) — System Architect — Architecture, ADRs, epics & stories (Dev Studio)
 - **Oholiab** (אהליאב) — Senior Engineer — TDD, sprint, code review, implementation (Dev Studio)
-- **Zecher** (זכר, Memory Guardian) — Memory Archivist — Persistent cross-session memory, consolidation, project scanning, context recall, session handoffs
+- **Backup Manager** (Backup & Restore) — Timestamped backups, restoration, and rotation (Backup)
+- **Animated Website Creator** (Website Builder) — Video-driven scrolling websites (Animated)
 
 ## Skills
 
@@ -98,19 +103,27 @@ Agents MUST follow these behavioral principles:
 - `.agents/memory/patterns.md` — Write when a reusable pattern is validated
 - `.agents/memory/context.md` — Update at session end with project state
 
+## Framework updates
+
+Once per session, check the installed framework before starting project work. If this is the BMAD+ source checkout, use `node tools/cli/bmad-plus-cli.js update-check --json`; otherwise use `npx --no-install bmad-plus update-check --json` from the project root.
+If the command is unavailable or the result is off, unknown, offline or stale, continue the user task. Do not install a CLI just to perform this check or claim that an offline version is current.
+When `updateAvailable` is true and `canAutoApply` is true, run the same CLI with `update --latest --auto`. This follows the project update policy; it does not grant permission to expand that policy.
+When an update is available but automatic application is not eligible, explain the version and reason. An explicit request to update can be fulfilled with `update --latest --yes`; do not change the policy, overwrite customized files, or resolve conflicts without the user request covering that action.
+After a successful update, reread the project spine and relevant installed skills, or start a fresh session if the client cannot reload them. Respect preserved local instructions. Check only once even when several adapters include this section.
+
 ## Registry facts (computed from registry.yaml — never hand-typed)
 
-- Product: BMAD+ v0.12.2 (derived from BMAD-METHOD v6.6.0)
+- Product: BMAD+ v0.14.0 (derived from BMAD-METHOD v6.6.0)
 - Models supported: claude, gpt, gemini, local (model-agnostic by contract)
 - Packs (9): Core, OSINT, Maker, Shield, SEO, Memory, Dev Studio, Backup, Animated
 - Installer agents (14 across all packs):
   - Core (required): 4 installer agents — Core agents & skills
   - OSINT: 1 installer agent — OSINT & investigation — 2 compliance frameworks
   - Maker: 1 installer agent — Agent creation toolkit
-  - Shield: 1 installer agent — GRC compliance (25+ frameworks) — 27 specialized agents, 11 workflows, 26 compliance frameworks
+  - Shield: 1 installer agent — GRC compliance (26 frameworks) — 27 specialized agents, 11 workflows, 26 compliance frameworks
   - SEO: 3 installer agents — SEO audit & optimization — 1 compliance frameworks
   - Memory: 1 installer agent — Persistent cross-session memory
-  - Dev Studio: 1 installer agent — SDLC automation (6 agents, 56+ skills) — 6 sub-agents, 38 workflows
+  - Dev Studio: 1 installer agent — SDLC automation (6 agents, specialized workflows) — 6 sub-agents, 38 workflows
   - Backup: 1 installer agent — Backup & restore
   - Animated: 1 installer agent — Animated website agents
 

package/tools/build/generated-adapters/.cursor/rules/bmad-plus.mdc

@@ -33,16 +33,21 @@ To activate an agent, say its name or persona:
 - **Forge** (Architect-Dev) — Architecture + Development + Documentation
 - **Sentinel** (Quality) — QA + UX review
 - **Nexus** (Orchestrator) — Sprint management + Autopilot + Parallel execution
-- **Shadow** (OSINT) — Investigation + Scraping + Psychoprofiling (if OSINT pack installed)
-- **Maker** (Agent Creator) — Design, build, validate, and package new BMAD+ agents
-- **Shield** (GRC) — Compliance agents for GDPR, ISO 27001, SOC 2, HIPAA, EU AI Act, DORA, NIS2 and more (derived counts: see Registry facts below)
+- **Shadow** (OSINT) — Investigation + Scraping + Psychoprofiling (OSINT)
+- **Maker** (Agent Creator) — Design, build, validate, and package new BMAD+ agents (Maker)
+- **Shield** (GRC) — Compliance agents for GDPR, ISO 27001, SOC 2, HIPAA, EU AI Act, DORA, NIS2 and more (Shield)
+- **SEO Scout** (Technical Scanner) — Crawling + technical inspection + performance (SEO)
+- **SEO Chief** (Strategist & Reporter) — Scoring + strategy + reporting (SEO)
+- **SEO Judge** (Content & AI Analyst) — Content quality + structured data + GEO analysis (SEO)
+- **Zecher** (זכר, Memory Guardian) — Memory Archivist — Persistent cross-session memory, consolidation, project scanning, context recall, session handoffs (Memory)
 - **Miriam** (מרים) — Business Analyst — Strategic analysis, research, product briefs (Dev Studio)
 - **Huldah** (חולדה) — Technical Writer — Documentation, diagrams, editorial review (Dev Studio)
 - **Yosef** (יוסף) — Product Manager — PRD, requirements, feature prioritization (Dev Studio)
 - **Rachel** (רחל) — UX Designer — User experience, wireframes, empathy mapping (Dev Studio)
 - **Bezalel** (בצלאל) — System Architect — Architecture, ADRs, epics & stories (Dev Studio)
 - **Oholiab** (אהליאב) — Senior Engineer — TDD, sprint, code review, implementation (Dev Studio)
-- **Zecher** (זכר, Memory Guardian) — Memory Archivist — Persistent cross-session memory, consolidation, project scanning, context recall, session handoffs
+- **Backup Manager** (Backup & Restore) — Timestamped backups, restoration, and rotation (Backup)
+- **Animated Website Creator** (Website Builder) — Video-driven scrolling websites (Animated)
 
 ## Skills
 
@@ -103,19 +108,27 @@ Agents MUST follow these behavioral principles:
 - `.agents/memory/patterns.md` — Write when a reusable pattern is validated
 - `.agents/memory/context.md` — Update at session end with project state
 
+## Framework updates
+
+Once per session, check the installed framework before starting project work. If this is the BMAD+ source checkout, use `node tools/cli/bmad-plus-cli.js update-check --json`; otherwise use `npx --no-install bmad-plus update-check --json` from the project root.
+If the command is unavailable or the result is off, unknown, offline or stale, continue the user task. Do not install a CLI just to perform this check or claim that an offline version is current.
+When `updateAvailable` is true and `canAutoApply` is true, run the same CLI with `update --latest --auto`. This follows the project update policy; it does not grant permission to expand that policy.
+When an update is available but automatic application is not eligible, explain the version and reason. An explicit request to update can be fulfilled with `update --latest --yes`; do not change the policy, overwrite customized files, or resolve conflicts without the user request covering that action.
+After a successful update, reread the project spine and relevant installed skills, or start a fresh session if the client cannot reload them. Respect preserved local instructions. Check only once even when several adapters include this section.
+
 ## Registry facts (computed from registry.yaml — never hand-typed)
 
-- Product: BMAD+ v0.12.2 (derived from BMAD-METHOD v6.6.0)
+- Product: BMAD+ v0.14.0 (derived from BMAD-METHOD v6.6.0)
 - Models supported: claude, gpt, gemini, local (model-agnostic by contract)
 - Packs (9): Core, OSINT, Maker, Shield, SEO, Memory, Dev Studio, Backup, Animated
 - Installer agents (14 across all packs):
   - Core (required): 4 installer agents — Core agents & skills
   - OSINT: 1 installer agent — OSINT & investigation — 2 compliance frameworks
   - Maker: 1 installer agent — Agent creation toolkit
-  - Shield: 1 installer agent — GRC compliance (25+ frameworks) — 27 specialized agents, 11 workflows, 26 compliance frameworks
+  - Shield: 1 installer agent — GRC compliance (26 frameworks) — 27 specialized agents, 11 workflows, 26 compliance frameworks
   - SEO: 3 installer agents — SEO audit & optimization — 1 compliance frameworks
   - Memory: 1 installer agent — Persistent cross-session memory
-  - Dev Studio: 1 installer agent — SDLC automation (6 agents, 56+ skills) — 6 sub-agents, 38 workflows
+  - Dev Studio: 1 installer agent — SDLC automation (6 agents, specialized workflows) — 6 sub-agents, 38 workflows
   - Backup: 1 installer agent — Backup & restore
   - Animated: 1 installer agent — Animated website agents