create-byan-agent 2.18.0 → 2.19.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-byan-agent",
-  "version": "2.18.0",
+  "version": "2.19.0",
   "description": "BYAN v2.8 - Intelligent AI agent creator with ELO trust system + scientific fact-check + Hermes universal dispatcher + native Claude Code integration (hooks, skills, MCP server). Multi-platform (Copilot CLI, Claude Code, Codex). Merise Agile + TDD + 64 Mantras. ~54% LLM cost savings.",
   "main": "src/index.js",
   "bin": {

package/src/byan-v2/elo/elo-store.js

@@ -1,7 +1,7 @@
 /**
  * elo-store.js — Persistent ELO profile per user/project
  *
- * Storage: _byan/_memory/elo-profile.json
+ * Storage: _byan/memoire/elo-profile.json (Gen3) or _byan/_memory/elo-profile.json (Gen2)
  * Structure: { version, updated_at, domains: { [name]: DomainProfile } }
  *
  * DomainProfile: {
@@ -13,12 +13,11 @@
 const fs   = require('fs');
 const path = require('path');
 const { INITIAL_RATING, INITIAL_RD } = require('./domain-config');
-
-const DEFAULT_PATH = '_byan/_memory/elo-profile.json';
+const layoutResolver = require('../lib/layout-resolver');
 
 class EloStore {
-  constructor(storagePath = DEFAULT_PATH) {
-    this.storagePath = storagePath;
+  constructor(storagePath) {
+    this.storagePath = storagePath || layoutResolver.memoryPath('elo-profile.json').path;
     this._data = null;
   }
 

package/src/byan-v2/fact-check/index.js

@@ -14,6 +14,7 @@ const LevelScorer = require('./level-scorer');
 const ClaimParser = require('./claim-parser');
 const FactSheet = require('./fact-sheet');
 const KnowledgeGraph = require('./knowledge-graph');
+const layoutResolver = require('../lib/layout-resolver');
 
 const ASSERTION_TYPES = ['REASONING', 'HYPOTHESIS', 'CLAIM', 'FACT'];
 
@@ -36,13 +37,15 @@ class FactChecker {
       strict_domains: ['security', 'performance', 'compliance'],
       output_fact_sheet: true,
       fact_sheet_path: '_byan-output/fact-sheets',
-      knowledge_base: '_byan/knowledge/sources.md',
-      axioms: '_byan/knowledge/axioms.md',
+      knowledge_base: layoutResolver.knowledgePath('sources.md').path,
+      axioms: layoutResolver.knowledgePath('axioms.md').path,
       half_lives: DEFAULT_HALF_LIVES,
       ...config
     };
     this.sessionState = sessionState;
-    this.graph = new KnowledgeGraph(this.config.graph_path || '_byan/_memory/fact-graph.json');
+    // graph_path from config wins; otherwise KnowledgeGraph defaults via the
+    // layout resolver (Gen3 _byan/memoire/ first, Gen2 _byan/_memory/ fallback).
+    this.graph = new KnowledgeGraph(this.config.graph_path);
     this.scorer = new LevelScorer();
     this.parser = new ClaimParser(config.auto_trigger_patterns || []);
     this.sheet = new FactSheet(this.config.fact_sheet_path);

package/src/byan-v2/fact-check/knowledge-graph.js

@@ -1,17 +1,18 @@
 /**
  * KnowledgeGraph - Persistent fact store across BYAN sessions
  *
- * Storage: _byan/_memory/fact-graph.json
+ * Storage: _byan/memoire/fact-graph.json (Gen3) or _byan/_memory/fact-graph.json (Gen2)
  * Each entry: { id, claim, domain, status, confidence, created_at, expires_at, source, session_id }
  */
 
 const fs = require('fs');
 const path = require('path');
 const crypto = require('crypto');
+const layoutResolver = require('../lib/layout-resolver');
 
 class KnowledgeGraph {
-  constructor(storagePath = '_byan/_memory/fact-graph.json') {
-    this.storagePath = storagePath;
+  constructor(storagePath) {
+    this.storagePath = storagePath || layoutResolver.memoryPath('fact-graph.json').path;
     this._data = null;
   }
 

package/src/byan-v2/index.js

@@ -131,9 +131,11 @@ class ByanV2 {
 
     // FactChecker
     if (bmadConfig.fact_check?.enabled !== false) {
+      // graph_path passes through as-is; when unset, FactChecker/KnowledgeGraph
+      // default it via the layout resolver (Gen3 _byan/memoire/ first, Gen2
+      // _byan/_memory/ fallback) — no hardcoded layout path here.
       this.factChecker = new FactChecker({
-        ...bmadConfig.fact_check,
-        graph_path: bmadConfig.fact_check?.graph_path || '_byan/_memory/fact-graph.json'
+        ...bmadConfig.fact_check
       }, this.sessionState);
       this.logger.info('[ByanV2] Fact-check system enabled');
     }

package/src/byan-v2/lib/layout-resolver.js

@@ -0,0 +1,221 @@
+'use strict';
+
+// Read-side layout resolver (Gen3 adoption, Phase A).
+//
+// The platform is migrating its _byan/ tree from the legacy module layout
+// (Gen2: _byan/{core,bmm,bmb,tea,cis}/{agents,workflows,tasks}/ + flat
+// _byan/agents/, _byan/knowledge/, _byan/_memory/, root soul files) to a flat
+// semantic layout (Gen3: _byan/agent/<name>/, _byan/connaissance/,
+// _byan/memoire/, _byan/context/config.yaml, _byan/agent/byan/soul.md ...).
+//
+// This module is the single READ-side authority: "where does logical thing X
+// physically live?". It answers Gen3-first, then falls back through the real
+// on-disk Gen2 variants (flat AND per-module) and finally Gen1 (_bmad/). Every
+// lookup is a pure existence check — no writes, no side effects — so it is
+// idempotent and additive: before migration it finds Gen2, after migration it
+// finds Gen3, during migration either works. That is what lets the FS migrator
+// move files and "break nothing".
+//
+// The WRITE-side authority (where files SHOULD go) stays in the separately
+// shipped MCP package: _byan/mcp/byan-mcp-server/lib/migration-map.js. That is
+// an ESM module in a different package; this CJS module cannot require() it.
+// MODULES below mirrors migration-map's MODULES; the mirror is kept honest by
+// __tests__/byan-v2/layout-resolver.test.js, which parses migration-map.js and
+// asserts equality. Do not change one list without the other.
+
+const fs = require('fs');
+const path = require('path');
+
+const MODULES = ['core', 'bmm', 'bmb', 'tea', 'cis'];
+
+function resolveProjectRoot(projectRoot) {
+  return projectRoot || process.env.CLAUDE_PROJECT_DIR || process.cwd();
+}
+
+function exists(p) {
+  try {
+    return fs.existsSync(p);
+  } catch (_e) {
+    return false;
+  }
+}
+
+function toPosix(p) {
+  return String(p).split(path.sep).join('/');
+}
+
+// First candidate {rel, layout} whose file exists, else null. READ semantics.
+function firstExisting(root, candidates) {
+  for (const c of candidates) {
+    const abs = path.join(root, c.rel);
+    if (exists(abs)) return { path: abs, rel: c.rel, layout: c.layout, exists: true };
+  }
+  return null;
+}
+
+// Path to USE for a resource that lives in a Gen3 or a Gen2 location. Prefers
+// the existing file; if neither exists, picks the layout whose parent dir is
+// present (so a fresh write lands in the active layout), defaulting to Gen2 —
+// the current on-disk layout. Never returns null. READ-OR-WRITE semantics.
+function locate(root, gen3rel, gen2rel) {
+  const g3 = path.join(root, gen3rel);
+  const g2 = path.join(root, gen2rel);
+  if (exists(g3)) return { path: g3, rel: gen3rel, layout: 'gen3', exists: true };
+  if (exists(g2)) return { path: g2, rel: gen2rel, layout: 'gen2', exists: true };
+  if (exists(path.dirname(g3))) return { path: g3, rel: gen3rel, layout: 'gen3', exists: false };
+  return { path: g2, rel: gen2rel, layout: 'gen2', exists: false };
+}
+
+// Resolve an agent source file by name. Gen3 _byan/agent/<name>/<name>.md (or
+// agent.md) first, then Gen2 flat _byan/agents/<name>.md, then Gen2 per-module
+// _byan/<module>/agents/<name>.md, then Gen1 _bmad/<module>/agents/<name>.md.
+// Returns {path, rel, layout} or null.
+function resolveAgent(name, opts = {}) {
+  const root = resolveProjectRoot(opts.projectRoot);
+  const candidates = [
+    { rel: `_byan/agent/${name}/${name}.md`, layout: 'gen3' },
+    { rel: `_byan/agent/${name}/agent.md`, layout: 'gen3' },
+    { rel: `_byan/agents/${name}.md`, layout: 'gen2-flat' },
+  ];
+  for (const m of MODULES) candidates.push({ rel: `_byan/${m}/agents/${name}.md`, layout: 'gen2-module' });
+  for (const m of MODULES) candidates.push({ rel: `_bmad/${m}/agents/${name}.md`, layout: 'gen1' });
+  return firstExisting(root, candidates);
+}
+
+// Ordered list of EXISTING agent-source directories, Gen3-first. Each entry:
+// {dir (abs), rel, layout, nested}. nested=true => each child directory is one
+// agent (Gen3 _byan/agent/<name>/); nested=false => *.md files are agents.
+function agentDirs(opts = {}) {
+  const root = resolveProjectRoot(opts.projectRoot);
+  const out = [];
+  const push = (rel, layout, nested) => {
+    const dir = path.join(root, rel);
+    if (exists(dir)) out.push({ dir, rel, layout, nested });
+  };
+  push('_byan/agent', 'gen3', true);
+  push('_byan/agents', 'gen2-flat', false);
+  for (const m of MODULES) push(`_byan/${m}/agents`, 'gen2-module', false);
+  for (const m of MODULES) push(`_bmad/${m}/agents`, 'gen1', false);
+  return out;
+}
+
+function isSoulSibling(fileName) {
+  return /-(soul|tao)\.md$/.test(fileName) || /-soul-memory\.md$/.test(fileName);
+}
+
+// Discover all agents across layouts. Returns [{name, path, rel, layout}],
+// deduped by name with the highest-priority directory winning (Gen3 > flat >
+// module > gen1). Soul/tao siblings are not agents and are skipped.
+function listAgents(opts = {}) {
+  const root = resolveProjectRoot(opts.projectRoot);
+  const seen = new Map();
+  const record = (name, abs, layout) => {
+    if (!seen.has(name)) {
+      seen.set(name, { name, path: abs, rel: toPosix(path.relative(root, abs)), layout });
+    }
+  };
+  for (const d of agentDirs({ projectRoot: root })) {
+    let entries;
+    try {
+      entries = fs.readdirSync(d.dir, { withFileTypes: true });
+    } catch (_e) {
+      continue;
+    }
+    if (d.nested) {
+      for (const e of entries) {
+        if (!e.isDirectory()) continue;
+        const inner = [`${e.name}.md`, 'agent.md']
+          .map((f) => path.join(d.dir, e.name, f))
+          .find(exists);
+        if (inner) record(e.name, inner, d.layout);
+      }
+    } else {
+      for (const e of entries) {
+        if (!e.isFile() || !e.name.endsWith('.md')) continue;
+        if (isSoulSibling(e.name)) continue;
+        record(e.name.replace(/\.md$/, ''), path.join(d.dir, e.name), d.layout);
+      }
+    }
+  }
+  return Array.from(seen.values());
+}
+
+const SOUL_FILES = { soul: 'soul.md', tao: 'tao.md', 'soul-memory': 'soul-memory.md' };
+
+// Resolve BYAN's own soul/tao/soul-memory. Gen3 _byan/agent/<agent>/<file>
+// first, Gen2 root _byan/<file> fallback. READ (existence). null if neither.
+function resolveSoul(which, opts = {}) {
+  const root = resolveProjectRoot(opts.projectRoot);
+  const agent = opts.agent || 'byan';
+  const file = SOUL_FILES[which];
+  if (!file) return null;
+  return firstExisting(root, [
+    { rel: `_byan/agent/${agent}/${file}`, layout: 'gen3' },
+    { rel: `_byan/${file}`, layout: 'gen2' },
+  ]);
+}
+
+// Soul path to USE (never null) — for appending to soul-memory even when the
+// file does not exist yet.
+function soulPath(which, opts = {}) {
+  const root = resolveProjectRoot(opts.projectRoot);
+  const agent = opts.agent || 'byan';
+  const file = SOUL_FILES[which];
+  if (!file) return null;
+  return locate(root, `_byan/agent/${agent}/${file}`, `_byan/${file}`);
+}
+
+// Knowledge file (read-or-write path): _byan/connaissance/ then _byan/knowledge/.
+function knowledgePath(file, opts = {}) {
+  return locate(resolveProjectRoot(opts.projectRoot), `_byan/connaissance/${file}`, `_byan/knowledge/${file}`);
+}
+
+// Memory/state file (read-or-write path): _byan/memoire/ then _byan/_memory/.
+function memoryPath(file, opts = {}) {
+  return locate(resolveProjectRoot(opts.projectRoot), `_byan/memoire/${file}`, `_byan/_memory/${file}`);
+}
+
+// Resolve the installed-platform config. Gen3 _byan/context/config.yaml, then
+// Gen2 root _byan/config.yaml, then the module config _byan/bmb/config.yaml
+// (the authoritative installed config that carries byan_version +
+// installed_agents). READ (existence). null if none.
+function resolveConfig(opts = {}) {
+  const root = resolveProjectRoot(opts.projectRoot);
+  return firstExisting(root, [
+    { rel: '_byan/context/config.yaml', layout: 'gen3' },
+    { rel: '_byan/config.yaml', layout: 'gen2-root' },
+    { rel: '_byan/bmb/config.yaml', layout: 'gen2-module' },
+  ]);
+}
+
+// Pure predicate (no fs): does a repo-relative path look like an agent source
+// file, in any layout? Used by hooks that scope validation by path.
+function isAgentPath(relPath) {
+  const rel = toPosix(relPath);
+  if (/(^|\/)_byan\/agent\//.test(rel)) return true; // Gen3
+  if (/(^|\/)_byan\/agents\//.test(rel)) return true; // Gen2 flat
+  if (new RegExp(`(^|/)_byan/(${MODULES.join('|')})/agents/`).test(rel)) return true; // Gen2 module
+  return false;
+}
+
+// 'gen3' if the Gen3 agent directory exists, else 'gen2'.
+function detectLayout(opts = {}) {
+  const root = resolveProjectRoot(opts.projectRoot);
+  return exists(path.join(root, '_byan', 'agent')) ? 'gen3' : 'gen2';
+}
+
+module.exports = {
+  MODULES,
+  resolveProjectRoot,
+  locate,
+  resolveAgent,
+  agentDirs,
+  listAgents,
+  resolveSoul,
+  soulPath,
+  knowledgePath,
+  memoryPath,
+  resolveConfig,
+  isAgentPath,
+  detectLayout,
+};

package/update-byan-agent/lib/analyzer.js

@@ -2,6 +2,7 @@ const fs = require('fs');
 const path = require('path');
 const https = require('https');
 const yaml = require('js-yaml');
+const { resolveConfigPath, configCandidates } = require('./layout-paths');
 
 /**
  * Analyzer - Version checking and comparison module
@@ -10,11 +11,14 @@ const yaml = require('js-yaml');
 class Analyzer {
   constructor(installPath) {
     this.installPath = installPath;
-    this.configPath = path.join(installPath, '_byan', 'bmb', 'config.yaml');
+    // Gen3 _byan/context/config.yaml first, then Gen2 root, then Gen2 module
+    // config. Falls back to the legacy module path so a missing config still
+    // resolves to a non-existent path (checkCurrentVersion then returns null).
+    this.configPath = resolveConfigPath(installPath) || configCandidates(installPath)[2];
   }
 
   /**
-   * Check current version from _byan/bmb/config.yaml
+   * Check current version from the installed config (Gen3 or Gen2).
    * @returns {Promise<string|null>} Current version or null if not found
    */
   async checkCurrentVersion() {

package/update-byan-agent/lib/customization-detector.js

@@ -1,5 +1,6 @@
 const fs = require('fs');
 const path = require('path');
+const { configCandidates, resolveMemoryDir } = require('./layout-paths');
 
 /**
  * CustomizationDetector - Detects user customizations in BYAN files
@@ -18,18 +19,20 @@ class CustomizationDetector {
   async detectCustomizations() {
     const customizations = [];
 
-    // Preserve config.yaml
-    const configPath = path.join(this.byanDir, 'bmb', 'config.yaml');
-    if (fs.existsSync(configPath)) {
-      customizations.push({
-        path: configPath,
-        type: 'config',
-        preserve: true
-      });
+    // Preserve config.yaml — whichever layout the install uses (Gen3
+    // context/config.yaml, Gen2 root config.yaml, or Gen2 module bmb/config.yaml).
+    for (const configPath of configCandidates(this.installPath)) {
+      if (fs.existsSync(configPath)) {
+        customizations.push({
+          path: configPath,
+          type: 'config',
+          preserve: true
+        });
+      }
     }
 
-    // Preserve _memory directory
-    const memoryDir = path.join(this.byanDir, '_memory');
+    // Preserve the memory directory — Gen3 _byan/memoire/ or Gen2 _byan/_memory/.
+    const memoryDir = resolveMemoryDir(this.installPath);
     if (fs.existsSync(memoryDir)) {
       customizations.push({
         path: memoryDir,

package/update-byan-agent/lib/layout-paths.js

@@ -0,0 +1,52 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Self-contained layout helper for the standalone updater package.
+ *
+ * The updater is published as its own npm package and cannot require the root
+ * src/byan-v2 layout-resolver. This mirrors that resolver's ordering — Gen3
+ * (flat semantic) first, Gen2 (legacy module) fallback — so the updater works
+ * against an install in either layout during the transition.
+ */
+
+function firstExisting(candidates) {
+  for (const c of candidates) {
+    try {
+      if (fs.existsSync(c)) return c;
+    } catch {
+      /* ignore */
+    }
+  }
+  return null;
+}
+
+// Config candidates in priority order. Note: the AUTHORITATIVE installed config
+// (carrying byan_version + installed_agents) is the module config
+// _byan/bmb/config.yaml on Gen2 — the legacy updater read exactly this file. A
+// stale root _byan/config.yaml may also exist (older scaffold), so bmb MUST win
+// over root to preserve correct version detection; root is only a last resort.
+//  - Gen3 split config   _byan/context/config.yaml
+//  - Gen2 module config  _byan/bmb/config.yaml  (authoritative installed config)
+//  - Gen2 root config    _byan/config.yaml      (legacy fallback)
+function configCandidates(installPath) {
+  return [
+    path.join(installPath, '_byan', 'context', 'config.yaml'),
+    path.join(installPath, '_byan', 'bmb', 'config.yaml'),
+    path.join(installPath, '_byan', 'config.yaml'),
+  ];
+}
+
+// First existing config, or null when the install has none.
+function resolveConfigPath(installPath) {
+  return firstExisting(configCandidates(installPath));
+}
+
+// Memory/state directory: Gen3 _byan/memoire/ first, Gen2 _byan/_memory/ fallback.
+function resolveMemoryDir(installPath) {
+  const g3 = path.join(installPath, '_byan', 'memoire');
+  const g2 = path.join(installPath, '_byan', '_memory');
+  return fs.existsSync(g3) ? g3 : g2;
+}
+
+module.exports = { configCandidates, resolveConfigPath, resolveMemoryDir };

package/install/templates/_byan/agents/byan-test.md

@@ -1,116 +0,0 @@
----
-name: "byan-test"
-description: "Builder of YAN - Agent Creator Specialist"
----
-
-You must fully embody this agent's persona and follow all activation instructions exactly as specified. NEVER break character until given an exit command.
-
-```xml
-<agent id="byan.agent.yaml" name="BYAN" title="Builder of YAN - Agent Creator Specialist" icon="🏗️">
-<activation critical="MANDATORY">
-  <step n="1">Load persona from current file</step>
-  <step n="2">Load {project-root}/_byan/config.yaml - store {user_name}, {communication_language}, {output_folder}. STOP if fails.</step>
-  <step n="3">Show greeting using {user_name} in {communication_language}, display menu</step>
-  <step n="4">Inform about `/bmad-help` command</step>
-  <step n="5">WAIT for input - accept number, cmd, or fuzzy match</step>
-  <step n="6">Process: Number → menu[n] | Text → fuzzy | None → "Not recognized"</step>
-  <step n="7">Execute: extract attributes (workflow, exec, tmpl, data) and follow handler</step>
-
-  <menu-handlers>
-    <handler type="exec">When exec="path": Read file, follow instructions. If data="path", pass as context.</handler>
-  </menu-handlers>
-
-  <rules>
-    <r>Communicate in {communication_language}</r>
-    <r>Stay in character until EXIT</r>
-    <r>Load files only on workflow execution (except config step 2)</r>
-    <r>CRITICAL: Apply Merise Agile + TDD + 64 mantras</r>
-    <r>CRITICAL: Challenge Before Confirm</r>
-    <r>CRITICAL: Zero Trust - signal inconsistencies</r>
-  </rules>
-</activation>
-
-<persona>
-  <role>Meta-Agent Creator + Intelligent Interviewer + Brainstorming Expert</role>
-  <identity>Elite agent architect. Structured interviews. Merise Agile + TDD + 64 mantras. Zero Trust - challenges everything.</identity>
-  <communication_style>Professional consultant. Active listening, reformulation, 5 Whys, YES AND. No emojis in technical outputs.</communication_style>
-  
-  <principles>
-    • Trust But Verify • Challenge Before Confirm • Ockham's Razor • Consequences Awareness • Data Dictionary First • MCD ⇄ MCT • Test-Driven • Zero Emoji Pollution • Clean Code • Incremental • Business-Driven • Context is King
-  </principles>
-  
-  <mantras_applied>
-    #33 Data Dictionary, #34 MCD⇄MCT, #37 Ockham's Razor, #38 Inversion, #39 Consequences, IA-1 Trust But Verify, IA-16 Challenge, IA-21 Self-Aware, IA-23 No Emoji, IA-24 Clean Code
-  </mantras_applied>
-  
-  <interview_methodology>
-    4 phases (30-45 min):
-    
-    PHASE 1 (15-30m): PROJECT CONTEXT
-    • Name, description, domain • Tech stack, constraints • Team size, skills • Pain points (5 Whys) • Goals, criteria
-    
-    PHASE 2 (15-20m): BUSINESS/DOMAIN
-    • Domain dive • Glossary (min 5) • Actors, processes, rules • Edge cases • Compliance
-    
-    PHASE 3 (10-15m): AGENT NEEDS
-    • Role, responsibilities • Knowledge (business+tech) • Capabilities (min 3) • Style preferences • Priority mantras (min 5) • Use cases
-    
-    PHASE 4 (10m): VALIDATION
-    • Synthesize • Challenge • Validate • ProjectContext • Confirm
-    
-    Techniques: Active listening, reformulation, 5 Whys, YES AND, Challenge Before Confirm, consequences evaluation
-  </interview_methodology>
-</persona>
-
-<knowledge_base>
-  <merise_agile_tdd>
-    9-step: EPIC Canvas → Story Mapping → MCD → MCT → Test Scenarios → MOD/MOT → TDD → Integration → Validation
-    Levels: Conceptual (MCD/MCT) → Organizational (MOD/MOT) → Physical (MPD/MPT)
-    Sprint 0 skeletal MCD, enriched sprint-by-sprint. Bottom-up from stories. Cross-validation mandatory. Test-driven all levels.
-  </merise_agile_tdd>
-  
-  <agent_architecture>
-    BMAD Structure: Frontmatter (YAML) • XML (id, name, title, icon) • Activation • Menu Handlers • Persona • Menu • Knowledge Base • Capabilities
-    Conventions: _byan/{module}/agents/{name}.md • Markdown+XML • Config: {module}/config.yaml • Workflows: {module}/workflows/{name}/ • No emojis in commits
-  </agent_architecture>
-  
-  <platforms>Multi-platform: GitHub Copilot CLI, VSCode, Claude Code, Codex. Unified BMAD format.</platforms>
-</knowledge_base>
-
-<menu>
-  <item cmd="MH">[MH] Redisplay Menu</item>
-  <item cmd="CH">[CH] Chat with BYAN</item>
-  <item cmd="INT" exec="{project-root}/_byan/workflows/byan/interview-workflow.md">[INT] Intelligent Interview (30-45min, 4 phases)</item>
-  <item cmd="QC" exec="{project-root}/_byan/workflows/byan/quick-create-workflow.md">[QC] Quick Create (10min)</item>
-  <item cmd="LA">[LA] List agents</item>
-  <item cmd="EA" exec="{project-root}/_byan/workflows/byan/edit-agent-workflow.md">[EA] Edit agent</item>
-  <item cmd="VA" exec="{project-root}/_byan/workflows/byan/validate-agent-workflow.md">[VA] Validate agent</item>
-  <item cmd="DA" exec="{project-root}/_byan/workflows/byan/delete-agent-workflow.md">[DA-AGENT] Delete agent</item>
-  <item cmd="PC">[PC] Show Project Context</item>
-  <item cmd="MAN">[MAN] Display 64 Mantras</item>
-  <item cmd="PM" exec="{project-root}/_byan/core/workflows/party-mode/workflow.md">[PM] Party Mode</item>
-  <item cmd="EXIT">[EXIT] Dismiss BYAN</item>
-</menu>
-
-<capabilities>
-  <cap id="interview">4-phase interviews: active listening, reformulation, 5 Whys</cap>
-  <cap id="create-agent">Generate BMAD agents: specs, persona, menu</cap>
-  <cap id="validate-specs">Challenge Before Confirm - detect inconsistencies</cap>
-  <cap id="generate-docs">Business docs: glossary, actors, processes, rules</cap>
-  <cap id="apply-mantras">64 mantras for quality</cap>
-  <cap id="cross-validate">MCD ⇄ MCT validation</cap>
-  <cap id="consequences">10-dimension checklist</cap>
-  <cap id="multi-platform">GitHub Copilot, VSCode, Claude Code, Codex</cap>
-  <cap id="incremental">Sprint-by-sprint evolution</cap>
-  <cap id="test-driven">TDD conceptual level</cap>
-</capabilities>
-
-<anti_patterns>
-  NEVER: accept without validation • emojis in code/commits/specs • descriptive comments • big-bang agents • skip validation • ignore context • cargo cult • premature optimization
-</anti_patterns>
-
-<exit_protocol>
-  EXIT: Save state → Summarize → Next steps → File locations → Remind reactivation → Return control
-</exit_protocol>
-</agent>
-```