bmad-plus 0.22.0 → 0.23.0

package/tools/cli/lib/pack-copy.js

@@ -8,11 +8,90 @@ const crypto = require('node:crypto');
 const { safeTarget } = require('../../build/generate-adapters');
 
 const fileHash = (content) => crypto.createHash('sha256').update(content).digest('hex');
+const MAX_MANIFEST = 1024 * 1024;
 
-function listPackFiles({ bmadSrc, targetAgentsDir, targetDataDir, projectRoot, pack }) {
+/** The package name comes from the generated registry data, never from user input. */
+function resolveModule(name, projectRoot) {
+  return require.resolve(name + '/package.json', { paths: [projectRoot] });
+}
+
+/** The node_modules directories Node searches from the BMAD+ package root upwards. */
+function moduleChain(projectRoot) {
+  const chain = [];
+  let current = fs.realpathSync(projectRoot);
+  for (;;) {
+    if (path.basename(current) !== 'node_modules') chain.push(path.join(current, 'node_modules'));
+    const parent = path.dirname(current);
+    if (parent === current) return chain;
+    current = parent;
+  }
+}
+
+/**
+ * The root of an `external_module` package installed next to BMAD+, once its
+ * version is the one the registry pinned. Node resolves through symlinks, so the
+ * resolved package must sit in the node_modules chain itself: a link or a global
+ * module path is refused.
+ */
+function externalModuleRoot({ externalModule, projectRoot, resolve = resolveModule }) {
+  const { package: name, version } = externalModule;
+  let manifestPath;
+  try {
+    manifestPath = resolve(name, projectRoot);
+  } catch (error) {
+    throw new Error(
+      'External module ' + name + ' is not installed next to BMAD+: ' + error.message,
+      { cause: error }
+    );
+  }
+  const expected = moduleChain(projectRoot).map((dir) =>
+    path.join(dir, ...name.split('/'), 'package.json')
+  );
+  if (!expected.includes(manifestPath)) {
+    throw new Error(
+      'External module ' +
+        name +
+        ' resolved to ' +
+        manifestPath +
+        ', outside the node_modules chain of this BMAD+. A symlinked package, a global module path and the isolated layout of pnpm (node_modules/.pnpm) are refused: install bmad-plus with npm so its pinned dependency sits in that chain.'
+    );
+  }
+  const root = path.dirname(manifestPath);
+  safeTarget(root, 'package.json');
+  const stat = fs.lstatSync(manifestPath);
+  if (!stat.isFile() || stat.size > MAX_MANIFEST)
+    throw new Error('External module ' + name + ' has no readable package.json');
+  let manifest;
+  try {
+    manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+  } catch (error) {
+    throw new Error('External module ' + name + ': ' + error.message, { cause: error });
+  }
+  if (!manifest || manifest.name !== name || manifest.version !== version) {
+    throw new Error(
+      'External module ' +
+        name +
+        ' is ' +
+        String(manifest && manifest.version) +
+        ' but this BMAD+ expects exactly ' +
+        version +
+        '; reinstall bmad-plus so its pinned dependency matches.'
+    );
+  }
+  return root;
+}
+
+function listPackFiles({
+  bmadSrc,
+  targetAgentsDir,
+  targetDataDir,
+  projectRoot,
+  pack,
+  resolveModule: resolve,
+}) {
   const result = { copiedAgents: 0, copiedSkills: 0, copiedFiles: 0, files: [] };
   if (!pack) return result;
-  function walk(source, target) {
+  function walk(source, target, root) {
     // Local Python execution must not turn interpreter caches into owned/shipped
     // framework files. Keep this aligned with the explicit npm files exclusions.
     if (path.basename(source) === '__pycache__' || /\.py[co]$/i.test(source)) return false;
@@ -26,9 +105,9 @@ function listPackFiles({ bmadSrc, targetAgentsDir, targetDataDir, projectRoot, p
     if (stat.isSymbolicLink()) throw new Error('Pack source is a symbolic link: ' + source);
     if (stat.isDirectory()) {
       for (const name of fs.readdirSync(source).sort())
-        walk(path.join(source, name), path.join(target, name));
+        walk(path.join(source, name), path.join(target, name), root);
     } else if (stat.isFile()) {
-      result.files.push({ source, target });
+      result.files.push(root ? { source, target, root } : { source, target });
     } else throw new Error('Pack source is not a regular file: ' + source);
     return true;
   }
@@ -49,6 +128,17 @@ function listPackFiles({ bmadSrc, targetAgentsDir, targetDataDir, projectRoot, p
     walk(path.join(projectRoot, pack.externalPackage, 'skills'), targetAgentsDir)
   )
     result.copiedSkills++;
+  if (pack.externalModule) {
+    const root = externalModuleRoot({ externalModule: pack.externalModule, projectRoot, resolve });
+    for (const name of pack.externalModule.skills) {
+      if (!walk(path.join(root, 'skills', name), path.join(targetAgentsDir, name), root)) {
+        throw new Error(
+          'External module ' + pack.externalModule.package + ' does not ship skill ' + name
+        );
+      }
+      result.copiedSkills++;
+    }
+  }
   if (
     pack.packDir &&
     walk(
@@ -105,4 +195,4 @@ function copyPackFiles(options) {
   return counts;
 }
 
-module.exports = { copyPackFiles, listPackFiles, copyManagedFile, fileHash };
+module.exports = { copyPackFiles, listPackFiles, copyManagedFile, externalModuleRoot, fileHash };

package/tools/cli/lib/packs.js

@@ -18,8 +18,10 @@ const PACKS = {
     ],
     "skills": [
       "bmad-plus-autopilot",
+      "bmad-plus-intake",
       "bmad-plus-parallel",
       "bmad-plus-sync",
+      "bmad-plus-swarm",
       "bmad-plus-uat"
     ],
     "data": [
@@ -103,6 +105,25 @@ const PACKS = {
     "packDir": "pack-animated",
     "packSrcDir": "packs",
     "desc": "Animated website agents"
+  },
+  "design": {
+    "name": "Design",
+    "icon": "d",
+    "agents": [],
+    "skills": [],
+    "externalModule": {
+      "package": "design-skill",
+      "version": "0.2.1",
+      "skills": [
+        "design",
+        "design-review",
+        "redesign"
+      ]
+    },
+    "packDir": "pack-design",
+    "packSrcDir": "packs",
+    "intake": "intake.yaml",
+    "desc": "Design engine: build, review and redesign interfaces"
   }
 };
 
@@ -115,7 +136,8 @@ const PACK_ORDER = [
   "memory",
   "dev-studio",
   "backup",
-  "animated"
+  "animated",
+  "design"
 ];
 
 const EXPECTED_AGENTS = {
@@ -184,6 +206,13 @@ const EXPECTED_AGENTS = {
     "packAgents": [
       "animated-website-agent.md"
     ]
+  },
+  "design": {
+    "agents": [],
+    "packDir": "pack-design",
+    "packAgents": [
+      "design-engine.md"
+    ]
   }
 };
 
@@ -191,7 +220,7 @@ const DERIVED = {
   "product": {
     "code": "bmad-plus",
     "displayName": "BMAD+",
-    "version": "0.22.0",
+    "version": "0.23.0",
     "derivedFrom": "BMAD-METHOD v6.6.0"
   },
   "packOrder": [
@@ -203,11 +232,12 @@ const DERIVED = {
     "memory",
     "dev-studio",
     "backup",
-    "animated"
+    "animated",
+    "design"
   ],
-  "packCount": 9,
-  "installerAgents": 14,
-  "totalAgents": 47,
+  "packCount": 10,
+  "installerAgents": 15,
+  "totalAgents": 48,
   "languages": [
     "en",
     "fr",
@@ -235,7 +265,7 @@ const DERIVED = {
       "workflowCount": 0,
       "frameworkCount": 0,
       "categoryCount": 0,
-      "skillCount": 4,
+      "skillCount": 6,
       "referenceFiles": 0,
       "categoryAgentCounts": [],
       "runtimes": [
@@ -247,8 +277,10 @@ const DERIVED = {
         ".agents/skills/agent-quality/SKILL.md",
         ".agents/skills/agent-orchestrator/SKILL.md",
         ".agents/skills/bmad-plus-autopilot/SKILL.md",
+        ".agents/skills/bmad-plus-intake/SKILL.md",
         ".agents/skills/bmad-plus-parallel/SKILL.md",
         ".agents/skills/bmad-plus-sync/SKILL.md",
+        ".agents/skills/bmad-plus-swarm/SKILL.md",
         ".agents/skills/bmad-plus-uat/SKILL.md",
         ".agents/data/role-triggers.yaml"
       ],
@@ -481,6 +513,7 @@ const DERIVED = {
           "alias": "זכר, Memory Guardian"
         }
       ],
+      "cohabitationWarning": "Detects and links existing brains (_brain/, ~/.claude/memory/); NEVER overwrites memory files.",
       "summary": "Cross-session memory + project scanner + Karpathy guardrails.",
       "desc": "Persistent cross-session memory",
       "description": "Persistent cross-session memory"
@@ -564,6 +597,7 @@ const DERIVED = {
           "alias": "אהליאב"
         }
       ],
+      "cohabitationWarning": "Dev Studio agents overlap with Core (Atlas/Forge/Sentinel/Nexus); both can coexist.",
       "summary": "6 specialized agents + 38 workflows: Analysis → Planning → Architecture → Implementation → Review.",
       "desc": "SDLC automation (6 agents, specialized workflows)",
       "description": "SDLC automation (6 agents, specialized workflows)"
@@ -637,6 +671,62 @@ const DERIVED = {
       "summary": "Luxury scroll-driven website from video.",
       "desc": "Animated website agents",
       "description": "Animated website agents"
+    },
+    "design": {
+      "id": "design",
+      "order": 9,
+      "name": "Design",
+      "displayName": "Design",
+      "iconEmoji": "🎨",
+      "required": false,
+      "installerAgentCount": 1,
+      "categoryAgentCount": 0,
+      "agentCount": 1,
+      "subAgentCount": 0,
+      "workflowCount": 0,
+      "frameworkCount": 0,
+      "categoryCount": 0,
+      "skillCount": 0,
+      "referenceFiles": 0,
+      "categoryAgentCounts": [],
+      "runtimes": [
+        "node"
+      ],
+      "requiredResources": [
+        ".agents/skills/pack-design/design-engine.md",
+        ".agents/skills/design/SKILL.md",
+        ".agents/skills/design-review/SKILL.md",
+        ".agents/skills/redesign/SKILL.md",
+        ".agents/skills/pack-design/SKILL.md",
+        ".agents/skills/pack-design/intake.yaml"
+      ],
+      "personas": [
+        {
+          "id": "design-engine",
+          "name": "Atelier",
+          "role": "Design Engine",
+          "description": "Senior product designer and design engineer: surfaces, tokens, accessibility, audits, redesigns",
+          "usesSkills": [
+            "design",
+            "design-review",
+            "redesign"
+          ]
+        }
+      ],
+      "externalModule": {
+        "package": "design-skill",
+        "version": "0.2.1",
+        "skills": [
+          "design",
+          "design-review",
+          "redesign"
+        ]
+      },
+      "intake": "intake.yaml",
+      "cohabitationWarning": "Overlaps Sentinel's UX-review role and Dev Studio's Rachel (UX Designer); when this pack is installed its rules govern visual design and accessibility, and the others hand those over.",
+      "summary": "Atelier builds, audits and redesigns interfaces under checkable rules: intake first, semantic tokens, WCAG AA, every state covered, pre-flight before delivery.",
+      "desc": "Design engine: build, review and redesign interfaces",
+      "description": "Design engine: build, review and redesign interfaces"
     }
   },
   "pythonPacks": {

package/tools/cli/lib/swarm-deal.js

@@ -0,0 +1,116 @@
+/** Deterministic dealing: the same profile, n and seed give the same cards, on any platform. */
+'use strict';
+
+const crypto = require('node:crypto');
+
+const WORD = 2 ** 32;
+
+/** A counter-mode generator over SHA-256: the stream depends on the seed alone. */
+class Dealer {
+  constructor(seed) {
+    this.seed = String(seed);
+    this.block = 0;
+    this.words = [];
+  }
+
+  next() {
+    if (!this.words.length) {
+      const digest = crypto
+        .createHash('sha256')
+        .update(this.seed + ':' + this.block)
+        .digest();
+      this.block += 1;
+      for (let offset = 0; offset < digest.length; offset += 4)
+        this.words.push(digest.readUInt32BE(offset));
+    }
+    return this.words.shift();
+  }
+
+  /** Uniform integer in [0, n): values above the last full cycle are rejected, never folded. */
+  below(n) {
+    const limit = WORD - (WORD % n);
+    let value = this.next();
+    while (value >= limit) value = this.next();
+    return value % n;
+  }
+
+  between(low, high) {
+    if (Number.isInteger(low) && Number.isInteger(high)) return low + this.below(high - low + 1);
+    return Math.round((low + (this.next() / WORD) * (high - low)) * 100) / 100;
+  }
+
+  shuffle(items) {
+    for (let index = items.length - 1; index > 0; index -= 1) {
+      const other = this.below(index + 1);
+      [items[index], items[other]] = [items[other], items[index]];
+    }
+    return items;
+  }
+}
+
+/** Largest-remainder quotas: the counts add up to n exactly and follow the shares. */
+function quotas(shares, n) {
+  const exact = shares.map((share) => share * n);
+  const counts = exact.map((value) => Math.floor(value));
+  let left = n - counts.reduce((sum, count) => sum + count, 0);
+  const order = exact
+    .map((value, index) => ({ index, remainder: value - Math.floor(value) }))
+    .sort((a, b) => b.remainder - a.remainder || a.index - b.index);
+  for (const { index } of order) {
+    if (left === 0) break;
+    counts[index] += 1;
+    left -= 1;
+  }
+  return counts;
+}
+
+function unitId(prefix, position, n) {
+  return prefix + String(position).padStart(Math.max(3, String(n).length), '0');
+}
+
+function dealCards(profile, n, seed, idPrefix) {
+  const dealer = new Dealer(seed);
+  const slots = profile.dimensions.map((dimension) => {
+    const counts = quotas(
+      dimension.values.map((entry) => entry.share),
+      n
+    );
+    const column = [];
+    counts.forEach((count, index) => {
+      for (let k = 0; k < count; k += 1) column.push(index);
+    });
+    return dealer.shuffle(column);
+  });
+  const cards = [];
+  for (let position = 0; position < n; position += 1) {
+    const card = { id: unitId(idPrefix, position + 1, n) };
+    profile.dimensions.forEach((dimension, index) => {
+      const entry = dimension.values[slots[index][position]];
+      card[dimension.name] = entry.value;
+      // A note is a field of the whole dimension, so every card carries it, empty or not.
+      if (dimension.values.some((value) => value.note !== null))
+        card[dimension.name + '_note'] = entry.note ?? '';
+      for (const [name, [low, high]] of Object.entries(entry.ranges))
+        card[name] = dealer.between(low, high);
+    });
+    for (const [name, [low, high]] of Object.entries(profile.ranges))
+      card[name] = dealer.between(low, high);
+    for (const [name, pool] of Object.entries(profile.pools))
+      card[name] = pool[dealer.below(pool.length)];
+    cards.push(card);
+  }
+  return cards;
+}
+
+function listCards(units, idPrefix) {
+  const cards = units.map((unit, index) => ({
+    ...unit,
+    id: unit.id ?? unitId(idPrefix, index + 1, units.length),
+  }));
+  // Answer files are named by id, and some file systems fold case.
+  if (new Set(cards.map((card) => card.id.toLowerCase())).size !== cards.length)
+    throw new Error('Swarm: jury unit ids must be distinct once dealt, whatever their case.');
+  return cards;
+}
+
+module.exports = { Dealer, quotas, unitId, dealCards, listCards };

package/tools/cli/lib/swarm-defaults.js

@@ -0,0 +1,6 @@
+/** The swarm block bmad-plus install writes; an absent block in a project means these values. */
+'use strict';
+
+const SWARM_DEFAULTS = Object.freeze({ budget: 26, wave: 10, media_credits: 'ask' });
+
+module.exports = { SWARM_DEFAULTS };

package/tools/cli/lib/swarm-tally.js

@@ -0,0 +1,195 @@
+/** Counts valid answers by group; quotes stay verbatim and the disclosure comes first. */
+'use strict';
+
+const round = (value) => Math.round(value * 10000) / 10000;
+
+function stats(values) {
+  if (!values.length) return { count: 0, median: null, mean: null, min: null, max: null };
+  const sorted = [...values].sort((a, b) => a - b);
+  const middle = sorted.length >> 1;
+  const median = sorted.length % 2 ? sorted[middle] : (sorted[middle - 1] + sorted[middle]) / 2;
+  return {
+    count: sorted.length,
+    median: round(median),
+    mean: round(sorted.reduce((sum, value) => sum + value, 0) / sorted.length),
+    min: sorted[0],
+    max: sorted[sorted.length - 1],
+  };
+}
+
+function rateOf(rows, field) {
+  const of = rows.length;
+  const yes = rows.filter(({ answer }) => answer[field] === true).length;
+  return { yes, of, rate: of ? round(yes / of) : null };
+}
+
+function countsOf(rows, field, values) {
+  const counts = Object.fromEntries(values.map((value) => [value, 0]));
+  for (const { answer } of rows) if (Object.hasOwn(answer, field)) counts[answer[field]] += 1;
+  return counts;
+}
+
+function quotesOf(rows, field, keep) {
+  return rows
+    .filter(({ answer }) => typeof answer[field] === 'string' && answer[field].trim())
+    .slice(0, keep)
+    .map(({ card, answer }) => ({ unit: card.id, text: answer[field] }));
+}
+
+function numbersOf(rows, field) {
+  return stats(
+    rows.map(({ answer }) => answer[field]).filter((value) => typeof value === 'number')
+  );
+}
+
+/**
+ * @param rows valid answers in unit order: [{ card, answer }]
+ * @param skipped units without a valid answer: [{ unit, reason }]
+ */
+function tally({ run, definition, cards, rows, skipped }) {
+  const { groupBy } = definition.tally;
+  const groupValues = Object.fromEntries(
+    groupBy.map((field) => [field, [...new Set(cards.map((card) => String(card[field])))]])
+  );
+  const partition = (compute) => ({
+    all: compute(rows),
+    groups: Object.fromEntries(
+      groupBy.map((field) => [
+        field,
+        Object.fromEntries(
+          groupValues[field].map((value) => [
+            value,
+            compute(rows.filter(({ card }) => String(card[field]) === value)),
+          ])
+        ),
+      ])
+    ),
+  });
+  const { rate, counts, quotes, numbers } = definition.tally;
+  return {
+    schemaVersion: 1,
+    run: run.id,
+    definition: definition.id,
+    kind: definition.kind,
+    title: definition.title,
+    disclosure: definition.disclosure,
+    units: { total: cards.length, valid: rows.length, skipped },
+    groupBy,
+    rate: rate ? { field: rate, ...partition((set) => rateOf(set, rate)) } : null,
+    counts: Object.fromEntries(
+      counts.map((field) => [
+        field,
+        partition((set) => countsOf(set, field, definition.answer.fields[field].values)),
+      ])
+    ),
+    quotes: Object.fromEntries(
+      Object.entries(quotes).map(([field, keep]) => [
+        field,
+        { keep, ...partition((set) => quotesOf(set, field, keep)) },
+      ])
+    ),
+    numbers: Object.fromEntries(
+      numbers.map((field) => [field, partition((set) => numbersOf(set, field))])
+    ),
+  };
+}
+
+const percent = (rate) => (rate === null ? 'n/a' : (rate * 100).toFixed(1) + '%');
+const cell = (value) => (value === null ? 'n/a' : String(value));
+
+function sections(section, render) {
+  const lines = render('all', section.all);
+  for (const [field, values] of Object.entries(section.groups))
+    for (const [value, subset] of Object.entries(values))
+      lines.push(...render(field + ' = ' + value, subset));
+  return lines;
+}
+
+function renderTally(result) {
+  const lines = [
+    '> ' + result.disclosure,
+    '',
+    '# ' + result.title + ' (run ' + result.run + ')',
+    '',
+  ];
+  const skipped = result.units.skipped;
+  lines.push(
+    result.units.valid +
+      ' of ' +
+      result.units.total +
+      ' units gave a valid answer; ' +
+      skipped.length +
+      ' skipped' +
+      (skipped.length
+        ? ': ' + skipped.map((entry) => entry.unit + ' (' + entry.reason + ')').join(', ')
+        : '') +
+      '.'
+  );
+  if (result.rate) {
+    lines.push(
+      '',
+      '## Rate: ' + result.rate.field,
+      '',
+      '| group | yes | of | rate |',
+      '|---|---|---|---|'
+    );
+    lines.push(
+      ...sections(result.rate, (name, value) => [
+        '| ' + name + ' | ' + value.yes + ' | ' + value.of + ' | ' + percent(value.rate) + ' |',
+      ])
+    );
+  }
+  for (const [field, section] of Object.entries(result.counts)) {
+    const values = Object.keys(section.all);
+    lines.push(
+      '',
+      '## Counts: ' + field,
+      '',
+      '| group | ' + values.join(' | ') + ' |',
+      '|---|' + values.map(() => '---|').join('')
+    );
+    lines.push(
+      ...sections(section, (name, value) => [
+        '| ' + name + ' | ' + values.map((key) => value[key]).join(' | ') + ' |',
+      ])
+    );
+  }
+  for (const [field, section] of Object.entries(result.quotes)) {
+    lines.push('', '## Quotes: ' + field + ' (up to ' + section.keep + ' per group, verbatim)');
+    lines.push(
+      ...sections(section, (name, value) => [
+        '',
+        '**' + name + '**',
+        ...(value.length
+          ? value.map((quote) => '- ' + quote.unit + ': ' + JSON.stringify(quote.text))
+          : ['- (no quote)']),
+      ])
+    );
+  }
+  for (const [field, section] of Object.entries(result.numbers)) {
+    lines.push(
+      '',
+      '## Numbers: ' + field,
+      '',
+      '| group | count | median | mean | min | max |',
+      '|---|---|---|---|---|---|'
+    );
+    lines.push(
+      ...sections(section, (name, value) => [
+        '| ' +
+          [
+            name,
+            value.count,
+            cell(value.median),
+            cell(value.mean),
+            cell(value.min),
+            cell(value.max),
+          ].join(' | ') +
+          ' |',
+      ])
+    );
+  }
+  return lines.join('\n') + '\n';
+}
+
+module.exports = { tally, renderTally, stats };