bmad-method-test-architecture-enterprise 2.0.4-next.0 → 2.0.4-next.1

package/.claude-plugin/marketplace.json

@@ -31,7 +31,7 @@
       "name": "bmad-method-test-architecture-enterprise",
       "source": "./",
       "description": "Master Test Architect module for quality strategy, test generation in red and expand modes with automatic run-and-heal, combined framework and CI setup, CI/CD quality gates, and structured testing education. The CI and ATDD commands remain available with existing customizations. Part of the BMad Method ecosystem.",
-      "version": "2.0.4-next.0",
+      "version": "2.0.4-next.1",
       "author": {
         "name": "Murat K Ozcan (TEA Creator) & Brian (BMad) Madison"
       },

package/cli/lib/resolve-tea-config.js

@@ -230,6 +230,7 @@ function coercePactMcp(value, source = CONFIG_RELATIVE_PATH) {
   throw configError(`tea_pact_mcp from ${source} must be one of ${PACT_MCP_VALUES.join(' | ')}, got ${JSON.stringify(value)}`);
 }
 
+/** Accept configuration tables while excluding arrays, dates and null. */
 function isPlainObject(value) {
   return value !== null && typeof value === 'object' && !Array.isArray(value) && !(value instanceof Date);
 }

package/cli/lib/test-design-parser.js

@@ -270,20 +270,53 @@ function readRisks(tables) {
   // one had the second half vanish with nothing reported. They are counted so the
   // caller can fail on them.
   const unscored = [];
+  const residualReferences = new Map();
   for (const table of tables) {
     if (table.reference) continue;
     const idColumn = columnIndex(table.header, ['Risk ID', 'RiskID', 'ID']);
     const scoreColumn = columnIndex(table.header, ['Score', 'Risk Score']);
+    const hasRiskFields = ['Category', 'Risk Category', 'Probability', 'Impact'].some((name) => columnIndex(table.header, [name]) !== -1);
+    const statesRiskRegister = /\brisk(?:s| register| assessment)\b/i.test(table.headings.at(-1) ?? '');
     if (
       idColumn !== -1 &&
       scoreColumn === -1 &&
-      table.rows.some((row) => RISK_ID_PATTERN.test(String(row[idColumn] ?? '').toUpperCase()))
+      table.rows.some((row) => {
+        const id = String(row[idColumn] ?? '').trim();
+        return (
+          RISK_ID_PATTERN.test(id.toUpperCase()) ||
+          ((hasRiskFields || statesRiskRegister) && id !== '' && !/^\{.*\}$/.test(id) && !/^none$/i.test(id))
+        );
+      })
     ) {
-      unscored.push({ headings: table.headings, rows: table.rows.length });
+      const entry = { headings: table.headings, rows: table.rows.length };
+      unscored.push(entry);
+      const normalized = table.header.map((header) =>
+        String(header)
+          .toLowerCase()
+          .replaceAll(/[^a-z]/g, ''),
+      );
+      if (
+        String(table.headings.at(-1) ?? '')
+          .toLowerCase()
+          .replaceAll(/[^a-z]/g, '')
+          .startsWith('residualrisk') &&
+        normalized.some((header) => header.startsWith('residualrisk')) &&
+        normalized.includes('acceptancecondition') &&
+        !normalized.some((header) => ['category', 'riskcategory', 'probability', 'impact'].includes(header))
+      ) {
+        residualReferences.set(
+          entry,
+          table.rows.map((row) =>
+            String(row[idColumn] ?? '')
+              .trim()
+              .toUpperCase(),
+          ),
+        );
+      }
     }
     if (idColumn === -1 || scoreColumn === -1) continue;
     const categoryColumn = columnIndex(table.header, ['Category', 'Risk Category']);
-    const descriptionColumn = columnIndex(table.header, ['Description', 'Risk', 'Summary']);
+    const descriptionColumn = columnIndex(table.header, ['Description', 'Description and source evidence', 'Risk', 'Summary']);
     const probabilityColumn = columnIndex(table.header, ['Probability']);
     const impactColumn = columnIndex(table.header, ['Impact']);
     for (const row of table.rows) {
@@ -291,6 +324,16 @@ function readRisks(tables) {
       // A template row still carrying its own placeholder describes nothing, and
       // counting it would make an unfilled template score as a register.
       if (rawId === '' || /^\{.*\}$/.test(rawId)) continue;
+      // An explicitly empty band can carry a human-readable absence marker.
+      // Require all numeric cells empty so a scored or incomplete real risk
+      // cannot disappear through this exception.
+      if (
+        /^none$/i.test(rawId) &&
+        /^n\/a$/i.test(row[categoryColumn] ?? '') &&
+        /^no evidence-supported risk scored in this band\.?$/i.test(row[descriptionColumn] ?? '') &&
+        [probabilityColumn, impactColumn, scoreColumn].every((column) => column !== -1 && (row[column] ?? '').trim() === '')
+      )
+        continue;
       const id = rawId.toUpperCase();
       risks.push({
         id,
@@ -304,7 +347,14 @@ function readRisks(tables) {
       });
     }
   }
-  risks.unscoredTables = unscored;
+  const knownIds = new Set(risks.map((risk) => risk.id));
+  // A residual acceptance table may only reference IDs in the scored register.
+  // Its exact heading and columns distinguish it from an additional register;
+  // an unknown ID still reports an unscored table to every caller.
+  risks.unscoredTables = unscored.filter((entry) => {
+    const references = residualReferences.get(entry);
+    return !references || references.length === 0 || references.some((id) => !knownIds.has(id));
+  });
   return risks;
 }
 
@@ -332,7 +382,9 @@ function readCoverage(tables) {
       if (level === '' || /^\{.*\}$/.test(level)) continue;
       const linkCell = linkColumn === -1 ? '' : (row[linkColumn] ?? '');
       rows.push({
-        level,
+        // These observed qualifiers retain the E2E test level. Unknown values
+        // stay unchanged so validators and coverage oracles still reject them.
+        level: ['E2E performance', 'E2E operational'].includes(level) ? 'E2E' : level,
         priority,
         riskIds: [...String(linkCell).toUpperCase().matchAll(RISK_REFERENCE_PATTERN)].map((match) => match[0]),
         linkCell,

package/cli/lib/workflow-cli.js

@@ -8,6 +8,7 @@ const { runAgent } = require('./run-agent');
 const { assertAgentReady } = require('./agent-presence');
 const { classOfAgentError } = require('./runner-exit-codes');
 
+/** A classified workflow failure used by caller exit-code policies. */
 class WorkflowError extends Error {
   constructor(failureClass, message, options) {
     super(message, options);
@@ -15,12 +16,14 @@ class WorkflowError extends Error {
   }
 }
 const collect = (value, previous) => [...previous, value];
+/** Parse a bounded whole decimal without accepting partial or unsafe values. */
 function integer(value, name, { min = 1, max = Number.MAX_SAFE_INTEGER } = {}) {
   if (!/^\d+$/.test(String(value)) || !Number.isSafeInteger(Number(value)) || Number(value) < min || Number(value) > max) {
     throw new WorkflowError('usage', `${name} must be an integer from ${min} to ${max}`);
   }
   return Number(value);
 }
+/** Add the shared vendor, model, environment and execution controls. */
 function addAgentOptions(program) {
   return program
     .requiredOption(
@@ -34,6 +37,7 @@ function addAgentOptions(program) {
     .option('--timeout-ms <n>', 'wall-clock timeout per attempt in milliseconds', '1200000')
     .option('--retries <n>', 'additional attempts for transport failures or timeouts, from 0 to 3', '1');
 }
+/** Validate command-line controls and resolve the requested adapter invocation. */
 function agentOptions(options, projectRoot) {
   const timeout = integer(options.timeoutMs ?? '1200000', '--timeout-ms', { max: 2_147_483_647 });
   const retries = integer(options.retries ?? '1', '--retries', { min: 0, max: 3 });
@@ -63,6 +67,7 @@ function agentOptions(options, projectRoot) {
     cwd: projectRoot,
   };
 }
+/** Determine whether a resolved path is contained by the supplied root. */
 function inside(root, candidate) {
   const relative = path.relative(root, candidate);
   return relative === '' || (relative !== '..' && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative));
@@ -85,6 +90,7 @@ function projectPath(projectRoot, value, label = 'path') {
   if (!inside(root, resolved)) throw new WorkflowError('usage', `${label} resolves outside --project-root`);
   return resolved;
 }
+/** Resolve a readable regular input file confined to the consuming project. */
 function readInput(projectRoot, value, label = 'input') {
   const target = projectPath(projectRoot, value, label);
   let stat;
@@ -108,6 +114,7 @@ function resolveWorkflowSkill({ projectRoot, skillName, skillRoot }) {
     throw new WorkflowError('environment-configuration', `${skillName} is unavailable at ${root}: ${error.message}`, { cause: error });
   }
 }
+/** Activate the actual skill using authoritative config and caller run inputs. */
 function headlessPrompt({ skillRoot, projectRoot, resolvedConfig, operation = 'create', requestLines = [] }) {
   return [
     `Run the TEA skill at ${JSON.stringify(skillRoot)} for the project at ${JSON.stringify(projectRoot)}.`,
@@ -125,6 +132,7 @@ function headlessPrompt({ skillRoot, projectRoot, resolvedConfig, operation = 'c
     ...requestLines,
   ].join('\n');
 }
+/** Create a fresh readable JSON evidence record without overwriting a prior one. */
 function jsonFile(target, value) {
   fs.writeFileSync(target, `${JSON.stringify(value, null, 2)}\n`, { flag: 'wx' });
 }
@@ -232,6 +240,7 @@ function runWithEvidence({
   lastError.runDir = runDir;
   throw lastError;
 }
+/** Print a retained-evidence diagnostic and map failures to public CLI codes. */
 function mainError(name, error) {
   process.stderr.write(`${name}: ${error.message}${error.runDir ? `; evidence: ${error.runDir}` : ''}\n`);
   return ['environment-transport', 'environment-timeout', 'environment-parser'].includes(error.failureClass) ? 3 : 2;

package/cli/test-design.js

@@ -0,0 +1,410 @@
+#!/usr/bin/env node
+/** Generate a project test plan through the packaged test-design skill. */
+'use strict';
+const fs = require('node:fs');
+const path = require('node:path');
+const crypto = require('node:crypto');
+const yaml = require('js-yaml');
+const MarkdownIt = require('markdown-it');
+const { Command } = require('commander');
+const { resolveTeaConfig } = require('./lib/resolve-tea-config');
+const { readDesign, RISK_ID_PATTERN, bandFor } = require('./lib/test-design-parser');
+const {
+  WorkflowError,
+  addAgentOptions,
+  readInput,
+  projectPath,
+  resolveWorkflowSkill,
+  headlessPrompt,
+  runWithEvidence,
+  mainError,
+} = require('./lib/workflow-cli');
+const collect = (value, previous) => [...previous, value];
+const sectionMarkdown = new MarkdownIt();
+const digest = (file) => crypto.createHash('sha256').update(fs.readFileSync(file)).digest('hex');
+/** Resolve existing parents so publication checks include symlink aliases. */
+function canonicalDestination(file) {
+  if (fs.existsSync(file)) return fs.realpathSync(file);
+  return path.join(canonicalDestination(path.dirname(file)), path.basename(file));
+}
+/** Refuse publication onto a supplied input or another deliverable. */
+function checkPublication(destinations, inputs) {
+  const canonical = destinations.map(canonicalDestination);
+  const aliases = (a, b) => {
+    if (a === b) return true;
+    if (!fs.existsSync(a) || !fs.existsSync(b)) return false;
+    const left = fs.statSync(a);
+    const right = fs.statSync(b);
+    return left.dev === right.dev && left.ino === right.ino;
+  };
+  if (canonical.some((file) => inputs.some((input) => aliases(file, input))))
+    throw new WorkflowError('usage', 'a published artifact aliases an input document; select a separate --output-dir');
+  if (canonical.some((file, index) => canonical.slice(0, index).some((other) => aliases(file, other))))
+    throw new WorkflowError('usage', 'published artifacts alias each other; select a separate --output-dir');
+}
+/** Require populated workflow sections and reject unresolved template scaffolding. */
+function validateSections(text, sections, label) {
+  const lines = text.match(/[^\n]*\n|[^\n]+$/g) ?? [];
+  const offsets = [0];
+  for (const line of lines) offsets.push(offsets.at(-1) + line.length);
+  const headings = [];
+  let quoted = 0;
+  let listed = 0;
+  for (const token of sectionMarkdown.parse(text, {})) {
+    if (token.type === 'blockquote_open') quoted += 1;
+    if (token.type === 'blockquote_close') quoted -= 1;
+    if (token.type === 'list_item_open') listed += 1;
+    if (token.type === 'list_item_close') listed -= 1;
+    if (token.type !== 'heading_open' || quoted || listed || !/^#{2,3}$/.test(token.markup)) continue;
+    const level = Number.parseInt(token.tag.slice(1), 10);
+    const [start, end] = token.map;
+    const source = lines[start].replace(/\r?\n$/, '');
+    const match = /^#{2,3}[ \t]+(.+?)[ \t]*#*[ \t]*$/.exec(source);
+    if (match) headings.push({ level, index: offsets[start], end: offsets[end], title: match[1] });
+  }
+  const equivalentHeading = (value) => value.replaceAll(/\band\b/gi, '&');
+  const normalizeHeading = (value) =>
+    equivalentHeading(value)
+      .replace(/^[\s\p{Extended_Pictographic}\p{Emoji_Presentation}\p{Symbol}\d.)\-:]+/u, '')
+      .replaceAll(/\s+/g, ' ')
+      .trim()
+      .toLowerCase();
+  for (const section of sections) {
+    const normalizedSection = normalizeHeading(section);
+    const escaped = equivalentHeading(section).replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`);
+    const heading =
+      headings.find((entry) => normalizeHeading(entry.title) === normalizedSection) ??
+      headings.find((entry) => new RegExp(`(?:^|\\b)${escaped}(?:\\b|$)`, 'i').test(equivalentHeading(entry.title)));
+    const stop = heading && headings.find((entry) => entry.index > heading.index && entry.level <= heading.level);
+    const body = heading && text.slice(heading.end, stop?.index ?? text.length);
+    const content = body
+      ?.replaceAll(/<!--[^]*?-->/g, '')
+      .replaceAll(/^#{1,6}[^\n]*$|^[-*_]{3,}\s*$/gm, '')
+      .trim();
+    if (!content) throw new WorkflowError('environment-parser', `${label} is missing populated section: ${section}`);
+  }
+  if (/<!--\s*TEA will populate|\{(?:Feature Name|project_name|timestamp|test_design_path)\}/i.test(text))
+    throw new WorkflowError('environment-parser', `${label} contains unresolved template placeholders`);
+}
+/** Read a fresh regular artifact confined to the current attempt. */
+function readArtifact(attemptDir, file) {
+  const target = projectPath(attemptDir, file, 'generated artifact');
+  if (!fs.existsSync(target) || !fs.statSync(target).isFile())
+    throw new WorkflowError('environment-parser', `required artifact was not written: ${file}`);
+  const text = fs.readFileSync(target, 'utf8');
+  if (!text.trim()) throw new WorkflowError('environment-parser', `required artifact is empty: ${file}`);
+  return { path: target, text };
+}
+/** Validate completion, preserved inputs, risk arithmetic and coverage references. */
+function validateDesign(context) {
+  const { attemptDir, artifactFiles, checkpointFile, runKey, inputDigests, planFile } = context;
+  for (const [file, expected] of inputDigests)
+    if (digest(file) !== expected) throw new WorkflowError('environment-parser', `the agent changed an input: ${file}`);
+  const artifacts = artifactFiles.map((file) => readArtifact(attemptDir, file));
+  if (context.runScope === 'system') {
+    const architecture = artifacts.find((artifact) => path.basename(artifact.path) === 'test-design-architecture.md');
+    const handoff = artifacts.find((artifact) => artifact.path.endsWith('-handoff.md'));
+    validateSections(
+      architecture.text,
+      [
+        'Executive Summary',
+        'Risk Assessment',
+        'NFR Testability Requirements',
+        'Testability Concerns and Architectural Gaps',
+        'Risk Mitigation Plans',
+        'Assumptions and Dependencies',
+      ],
+      'architecture report',
+    );
+    validateSections(
+      handoff.text,
+      [
+        'Purpose',
+        'TEA Artifacts Inventory',
+        'Epic-Level Integration Guidance',
+        'Story-Level Integration Guidance',
+        'Risk-to-Story Mapping',
+        'Recommended BMAD',
+        'Phase Transition Quality Gates',
+      ],
+      'handoff report',
+    );
+  }
+  const checkpoint = readArtifact(attemptDir, checkpointFile);
+  const match = checkpoint.text.match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/);
+  if (!match) throw new WorkflowError('environment-parser', 'the progress checkpoint has no YAML frontmatter');
+  const progress = yaml.load(match[1]);
+  if (
+    progress?.workflowStatus !== 'completed' ||
+    progress.runKey !== runKey ||
+    progress.runScope !== context.runScope ||
+    !Array.isArray(progress.stepsCompleted) ||
+    [
+      'step-01-detect-mode',
+      'step-02-load-context',
+      'step-03-risk-and-testability',
+      'step-04-coverage-plan',
+      'step-05-generate-output',
+    ].some((step) => !progress.stepsCompleted.includes(step)) ||
+    progress.lastStep !== 'step-05-generate-output' ||
+    progress.nextStep !== '' ||
+    progress.totalSteps !== 5
+  ) {
+    throw new WorkflowError('environment-parser', 'the progress checkpoint does not confirm completion of this run');
+  }
+  const report = artifacts.find((artifact) => artifact.path === path.join(attemptDir, planFile));
+  const planSections =
+    context.runScope === 'system'
+      ? [
+          'Executive Summary',
+          'Not in Scope',
+          'Dependencies & Test Blockers',
+          'Risk Assessment',
+          'NFR Test Coverage Plan',
+          'Entry Criteria',
+          'Exit Criteria',
+          'Test Coverage Plan',
+          'Execution Strategy',
+          'QA Effort Estimate',
+          'Interworking & Regression',
+          'Appendix A: Code Examples & Tagging',
+          'Appendix B: Knowledge Base References',
+        ]
+      : [
+          'Executive Summary',
+          'Not in Scope',
+          'Risk Assessment',
+          'NFR Planning',
+          'Entry Criteria',
+          'Exit Criteria',
+          'Test Coverage Plan',
+          'Execution Strategy',
+          'Resource Estimates',
+          'Quality Gate Criteria',
+          'Mitigation Plans',
+          'Assumptions and Dependencies',
+          'Follow-on Workflows',
+          'Approval',
+          'Interworking & Regression',
+          'Appendix',
+        ];
+  validateSections(report.text, planSections, context.runScope === 'system' ? 'QA plan' : 'epic plan');
+  const parsed = readDesign({ kind: 'text', value: report.text });
+  if (!parsed.ok) throw new WorkflowError('environment-parser', parsed.reason);
+  const { risks, coverage } = parsed.design;
+  if (parsed.design.unscoredTables.length > 0) throw new WorkflowError('environment-parser', 'the report contains unscored risk tables');
+  const ids = new Set();
+  for (const risk of risks) {
+    if (
+      !risk.description.trim() ||
+      !RISK_ID_PATTERN.test(risk.rawId) ||
+      ids.has(risk.id) ||
+      !['TECH', 'SEC', 'PERF', 'DATA', 'BUS', 'OPS'].includes(risk.category) ||
+      ![1, 2, 3].includes(risk.probability) ||
+      ![1, 2, 3].includes(risk.impact) ||
+      risk.score !== risk.probability * risk.impact
+    ) {
+      throw new WorkflowError('environment-parser', `invalid or duplicate scored risk row: ${risk.rawId}`);
+    }
+    const declared = bandFor(risk.headings);
+    if (!declared || risk.score < declared.band.min || risk.score > declared.band.max)
+      throw new WorkflowError('environment-parser', `scored risk ${risk.rawId} has a missing or contradictory score band`);
+    ids.add(risk.id);
+  }
+  if (
+    coverage.length === 0 ||
+    coverage.some(
+      (row) =>
+        !['P0', 'P1', 'P2', 'P3'].includes(row.priority) ||
+        !['E2E', 'API', 'Component', 'Integration', 'Unit'].includes(row.level) ||
+        row.riskIds.some((id) => !ids.has(id)),
+    ) ||
+    risks.some((risk) => !coverage.some((row) => row.riskIds.includes(risk.id)))
+  )
+    throw new WorkflowError(
+      'environment-parser',
+      'the coverage plan is empty, omits valid priorities, uses invalid levels, carries dangling references or leaves risks uncovered',
+    );
+  return { artifacts: [...artifacts, checkpoint], riskCount: risks.length, coverageCount: coverage.length };
+}
+/** Stage all deliverables and restore prior reports if a replacement fails. */
+function publishDesign(artifacts, { projectRoot, outputDir, runDir }, io = fs) {
+  const staged = [];
+  let keepBackups = false;
+  try {
+    for (const artifact of artifacts) {
+      const destination = projectPath(projectRoot, path.join(outputDir, 'test-design', path.basename(artifact.path)), 'published artifact');
+      const target = canonicalDestination(destination);
+      io.mkdirSync(path.dirname(target), { recursive: true });
+      const directory = io.mkdtempSync(path.join(path.dirname(target), '.tea-publish-'));
+      const item = {
+        destination,
+        target,
+        directory,
+        next: path.join(directory, 'next'),
+        previous: path.join(directory, 'previous'),
+        existed: io.existsSync(target),
+        installed: false,
+      };
+      staged.push(item);
+      if (item.existed) {
+        if (!io.statSync(target).isFile()) throw new Error(`publication destination is not a regular file: ${destination}`);
+        io.copyFileSync(target, item.previous);
+      }
+      io.copyFileSync(artifact.path, item.next);
+      if (item.existed) io.chmodSync(item.next, io.statSync(target).mode);
+    }
+    for (const item of staged) {
+      io.renameSync(item.next, item.target);
+      item.installed = true;
+    }
+    return staged.map((item) => item.destination);
+  } catch (error_) {
+    const rollbackErrors = [];
+    for (const item of staged.filter((entry) => entry.installed).toReversed()) {
+      try {
+        if (item.existed) io.renameSync(item.previous, item.target);
+        else io.unlinkSync(item.target);
+      } catch (error) {
+        rollbackErrors.push(`${item.destination}: ${error.message}`);
+      }
+    }
+    keepBackups = rollbackErrors.length > 0;
+    const status = keepBackups
+      ? `publication may contain mixed reports; recovery backups: ${staged.map((item) => item.directory).join(', ')}; rollback errors: ${rollbackErrors.join('; ')}`
+      : 'previous reports restored; no partial publication remains';
+    const error = new WorkflowError('environment-configuration', `could not publish artifacts: ${error_.message}; ${status}`, {
+      cause: error_,
+    });
+    error.runDir = runDir;
+    throw error;
+  } finally {
+    if (!keepBackups) {
+      for (const item of staged) {
+        try {
+          io.rmSync(item.directory, { recursive: true, force: true });
+        } catch (error) {
+          process.stderr.write(`publication staging cleanup failed at ${item.directory}: ${error.message}\n`);
+        }
+      }
+    }
+  }
+}
+/** Resolve user inputs, invoke the actual skill and publish verified deliverables. */
+function run(argv) {
+  const program = addAgentOptions(
+    new Command().name('tea-test-design').description('Generate and verify an epic or system test plan with the TEA test-design skill.'),
+  );
+  program
+    .option('--project-root <dir>', 'consuming project root', process.cwd())
+    .option('--skill-root <dir>', 'explicit trusted skill directory; defaults to the packaged skill')
+    .requiredOption('--input <path>', 'requirements or architecture document in the project (repeatable)', collect, [])
+    .option('--scope <name>', 'epic or system', 'epic')
+    .option('--epic <id>', 'epic number or stable slug; required for epic scope')
+    .option('--output-dir <dir>', 'published artifact root inside the project; defaults to TEA test_artifacts')
+    .option('--evidence-dir <dir>', 'retained prompts, raw streams and fresh artifacts inside the project', '.tea-runs')
+    .setOptionValue('retries', '0')
+    .exitOverride()
+    .configureOutput({ writeErr: () => {} });
+  try {
+    program.parse(argv);
+  } catch (error) {
+    if (error.exitCode === 0) return;
+    throw new WorkflowError('usage', error.message);
+  }
+  const options = program.opts();
+  const projectRoot = fs.realpathSync(path.resolve(options.projectRoot));
+  if (!['epic', 'system'].includes(options.scope)) throw new WorkflowError('usage', '--scope must be epic or system');
+  if (options.scope === 'epic' && (!options.epic || !/^[a-z0-9][a-z0-9-]{0,63}$/.test(options.epic)))
+    throw new WorkflowError('usage', 'epic scope requires --epic with a number or stable lowercase slug');
+  if (options.scope === 'system' && options.epic) throw new WorkflowError('usage', '--epic applies to epic scope');
+  if (options.scope === 'system' && options.input.length < 2)
+    throw new WorkflowError('usage', 'system scope requires PRD and architecture inputs, supplied with at least two --input options');
+  const inputs = [...new Set(options.input.map((file) => readInput(projectRoot, file, '--input')))];
+  if (options.scope === 'system' && inputs.length < 2)
+    throw new WorkflowError('usage', 'system scope requires two distinct input documents');
+  const inputDigests = inputs.map((file) => [file, digest(file)]);
+  const skillRoot = resolveWorkflowSkill({ projectRoot, skillName: 'bmad-testarch-test-design', skillRoot: options.skillRoot });
+  const resolvedConfig = resolveTeaConfig({ projectRoot, skillRoot, skillName: 'bmad-testarch-test-design' });
+  const outputValue =
+    options.outputDir || resolvedConfig.configSnapshot.modules.tea.test_artifacts.replaceAll('{project-root}', projectRoot);
+  const outputDir = projectPath(projectRoot, outputValue, '--output-dir');
+  const runKey = options.scope === 'epic' ? `epic-${options.epic}` : 'system';
+  const projectName =
+    path
+      .basename(projectRoot)
+      .toLowerCase()
+      .replaceAll(/[^a-z0-9]+/g, '-')
+      .replaceAll(/^-|-$/g, '') || 'project';
+  const planName = options.scope === 'epic' ? `test-design-epic-${options.epic}.md` : 'test-design-qa.md';
+  const publishedNames = options.scope === 'epic' ? [planName] : ['test-design-architecture.md', planName, `${projectName}-handoff.md`];
+  const destinations = [...publishedNames, `test-design-progress-${runKey}.md`].map((name) =>
+    projectPath(projectRoot, path.join(outputDir, 'test-design', name), 'published artifact'),
+  );
+  checkPublication(destinations, inputs);
+  const result = runWithEvidence({
+    name: 'tea-test-design',
+    projectRoot,
+    evidenceRoot: options.evidenceDir,
+    options,
+    prepare({ attemptDir }) {
+      const artifactsRoot = path.join(attemptDir, 'artifacts');
+      const config = {
+        ...resolvedConfig,
+        configSnapshot: {
+          core: { ...resolvedConfig.configSnapshot.core, project_name: projectName },
+          modules: { tea: { ...resolvedConfig.configSnapshot.modules.tea, test_artifacts: artifactsRoot } },
+        },
+      };
+      const artifactFiles = publishedNames.map((file) => path.join('artifacts', 'test-design', file));
+      const checkpointFile = path.join('artifacts', 'test-design', `test-design-progress-${runKey}.md`);
+      const requestLines = [
+        `Start Create mode at ${JSON.stringify(path.join(skillRoot, 'steps-c', 'step-01-detect-mode.md'))}.`,
+        `mode=${options.scope}-level; run_scope=${options.scope}; run_key=${runKey}; design_level=full`,
+        ...(options.scope === 'epic' ? [`epic_num=${options.epic}`] : []),
+        `project_name=${projectName}; test_artifacts=${JSON.stringify(artifactsRoot)}; tea_browser_automation=none`,
+        `Inputs are exactly this JSON list: ${JSON.stringify(inputs)}. Read them as the supplied requirements and architecture context.`,
+        'Do not discover other requirement documents. Do not generate tests or modify any input document.',
+        `Produce these deliverables: ${JSON.stringify(artifactFiles.map((file) => path.join(attemptDir, file)))}`,
+        `Save a completed progress checkpoint at ${JSON.stringify(path.join(attemptDir, checkpointFile))}.`,
+        'Use the workflow template and checklist. Complete all five steps and preserve its scored risk and coverage table schema.',
+      ];
+      return {
+        prompt: headlessPrompt({ skillRoot, projectRoot, resolvedConfig: config, requestLines }),
+        artifactFiles,
+        checkpointFile,
+        runKey,
+        runScope: options.scope,
+        inputDigests,
+        planFile: path.join('artifacts', 'test-design', planName),
+      };
+    },
+    validate: validateDesign,
+  });
+  if (result.dryRun) {
+    process.stdout.write(
+      `${JSON.stringify({ mode: 'prompt-only', evidence: result.runDir, prompt: path.join(result.attemptDir, 'prompt.txt') })}\n`,
+    );
+    return;
+  }
+  // Recheck after execution: the consuming project is writable during generation.
+  checkPublication(
+    destinations.map((file) => projectPath(projectRoot, file, 'published artifact')),
+    inputs,
+  );
+  const published = publishDesign(result.value.artifacts, { projectRoot, outputDir, runDir: result.runDir });
+  process.stdout.write(
+    `${JSON.stringify({ mode: 'live', runKey, evidence: result.runDir, artifacts: published, riskCount: result.value.riskCount, coverageCount: result.value.coverageCount })}\n`,
+  );
+}
+/** Convert configuration and agent failures to the documented CLI exit codes. */
+function main(argv) {
+  try {
+    run(argv);
+    return 0;
+  } catch (error) {
+    return mainError('tea-test-design', error);
+  }
+}
+if (require.main === module) process.exitCode = main(process.argv);
+module.exports = { main, validateDesign, publishDesign };

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "bmad-method-test-architecture-enterprise",
-  "version": "2.0.4-next.0",
+  "version": "2.0.4-next.1",
   "description": "Master Test Architect for quality strategy, test automation, and release gates",
   "keywords": [
     "bmad",
@@ -40,6 +40,7 @@
     "tea-nfr-runner": "cli/nfr-runner.js",
     "tea-routing-runner": "cli/routing-runner.js",
     "tea-skill-runner": "cli/skill-runner.js",
+    "tea-test-design": "cli/test-design.js",
     "tea-test-design-runner": "cli/test-design-runner.js",
     "tea-test-review": "cli/test-review.js",
     "tea-trace": "cli/trace.js",
@@ -90,7 +91,7 @@
     "release:minor": "gh workflow run publish.yaml -f channel=latest -f bump=minor",
     "release:next": "gh workflow run publish.yaml -f channel=next",
     "release:patch": "gh workflow run publish.yaml -f channel=latest -f bump=patch",
-    "test": "npm run test:conflict-markers && npm run test:schemas && npm run test:install && npm run test:evaluate-guidance && npm run test:evaluate-authoring && npm run test:evaluate-gap-loop && npm run test:evaluate-dogfood && npm run test:evaluate-check && npm run test:evaluate-compare && npm run test:evaluate-before-state && npm run test:evaluate-ci-gates && npm run test:evaluate-ci-tiers && npm run test:evaluate-ci-repositories:tagged-release-pr && npm run test:evaluate-ci-repositories:tagged-release-merge && npm run test:evaluate-ci-repositories:tagged-release-release && npm run test:evaluate-ci-repositories:nightly-deploy-pr && npm run test:evaluate-ci-repositories:nightly-deploy-merge && npm run test:evaluate-ci-repositories:nightly-deploy-scheduled && npm run test:evaluate-ci-repositories:nightly-deploy-release && npm run test:evaluate-ci-render && npm run test:evaluate-pr-mcp && npm run test:evaluate-pr-api && npm run test:evaluate-pr-suite && npm run test:evaluate-pr-workflow && npm run test:evaluate-pr-tool-use && npm run test:evaluate-pr-promptfoo && npm run test:evaluate-pr-ai-feature && npm run test:evaluate-pr-test-review && npm run test:evaluate-pr-gap-loop && npm run test:evaluate-pr-learn && npm run test:evaluate-pr-tutorial && npm run test:evaluate-partitions && npm run test:evaluate-partition-plans-views-and-check && npm run test:evaluate-partition-plans-preflight-and-run && npm run test:evaluate-partition-plans-score && npm run test:evaluate-partition-plans-attempts-seal-and-mappings && npm run test:evaluate-partition-plans-attempts-records && npm run test:evaluate-partition-plans-attempts-gameability && npm run test:evaluate-interpret && npm run test:evaluate-calibration && npm run test:evaluate-boundaries && npm run test:evaluate-preflight && npm run test:evaluate-isolation-conformance && npm run test:evaluate-mutation:qualification-basics && npm run test:evaluate-mutation:qualification-guards && npm run test:evaluate-mutation:recovery && npm run test:evaluate-mutation:journals && npm run test:evaluate-run && npm run test:evaluate-progress && npm run test:evaluate-aggregate && npm run test:evaluate-confinement && npm run test:evaluate-confinement-audit && npm run test:evaluate-confinement-history && npm run test:evaluate-confinement-git-state && npm run test:evaluate-confinement-network && npm run test:evaluate-held-inputs && npm run test:evaluate-arms-historical && npm run test:evaluate-arms-deployments && npm run test:evaluate-evaluators && npm run test:evaluate-evaluators-agent-version && npm run test:evaluate-agents && npm run test:evaluate-agents-importers && npm run test:evaluate-agents-sealed-brief && npm run test:evaluate-held-attempts && npm run test:evaluate-private && npm run test:evaluate-records && npm run test:evaluate-mcp && npm run test:evaluate-api && npm run test:evaluate-workflow && npm run test:evaluate-tool-use && npm run test:evaluate-promptfoo && npm run test:evaluate-learned-framework && npm run test:docs-tutorial && npm run test:knowledge && npm run test:criteria-fragments && npm run test:doc-count-sources && npm run test:planning-doc-sources && npm run test:doc-counts && npm run test:doc-claim-sources && npm run test:doc-claims && npm run test:doc-invocation-entry && npm run test:doc-invocations && npm run test:doc-link-anchors && npm run test:docs-build-names && npm run test:docs-evaluate-sidebar && npm run test:docs-gap-reader && npm run test:enforce-hook && npm run test:framework-scaffold && npm run test:isolation-primitives && npm run test:atdd-isolation && npm run test:atdd-net-guard && npm run test:atdd-scoring && npm run test:atdd-workflow-guidance && npm run test:generation-healing && npm run test:framework-scaffold-install-isolation && npm run test:transcript-harness && npm run test:suite-manifest && npm run test:teach-me-testing-scoring && npm run test:eval-data && npm run test:eval-atdd-data && npm run test:eval-ci-data && npm run test:eval-framework-scaffold-data && npm run test:eval-nfr-data && npm run test:nfr-validate-corpus && npm run test:nfr-evidence-guidance && npm run test:eval-test-design-data && npm run test:eval-trace-data && npm run test:eval-routing-data && npm run test:eval-routing-boundaries && npm run test:eval-routing-evidence && npm run test:eval-transcript-data && npm run test:eval-teach-me-testing-data && npm run test:eval-schemas && npm run test:eval-diagnostics && npm run test:eval-replay && npm run test:eval-quality-corpus && npm run test:schema-versions && npm run test:contract-sources && npm run test:contracts && npm run test:contract-oracles && npm run test:probe-sources && npm run test:test-design-qualification && npm run test:test-review-qualification && npm run test:trace-qualification && npm run test:nfr-qualification && npm run test:ci-qualification && npm run test:probe-corpus && npm run test:compare-dominance && npm run test:compare-eval-runs && npm run test:trial-set-scoring && npm run test:automate-cli && npm run test:automate-generation-evidence && npm run test:automate-eval-fixture && npm run test:eval-automate-data && npm run test:clock-port && npm run test:probe-conformance && npm run test:corpus-conformance && npm run test:file-system-conformance && npm run test:file-system-port && npm run test:probe-targets && npm run test:port-totality && npm run test:ci-coverage && npm run test:ci-coverage-filters && npm run test:install-actionlint && npm run test:workflows-lint && npm run test:install-linux-sandbox && npm run test:shards && npm run test:groups && npm run test:cli && npm run test:test-review-pr-scope && npm run test:test-review-report && npm run test:test-review-rubric && npm run test:bmad-output-gated && npm run test:release-metadata && npm run test:release-notes && npm run test:lockfile-age && npm run test:lockfile-age-cache && npm run test:licences && npm run test:supply-chain && npm run test:boundary && npm run test:direction && npm run test:lineage && npm run test:guard-publish && npm run test:layering-boundary-lineage && npm run test:changelog && npm run test:tea-workflow-descriptions && npm run test:docs-mermaid && npm run test:llms-headroom && npm run validate:schemas && npm run lint && npm run lint:md && npm run format:check",
+    "test": "npm run test:conflict-markers && npm run test:schemas && npm run test:install && npm run test:evaluate-guidance && npm run test:evaluate-authoring && npm run test:evaluate-gap-loop && npm run test:evaluate-dogfood && npm run test:evaluate-check && npm run test:evaluate-compare && npm run test:evaluate-before-state && npm run test:evaluate-ci-gates && npm run test:evaluate-ci-tiers && npm run test:evaluate-ci-repositories:tagged-release-pr && npm run test:evaluate-ci-repositories:tagged-release-merge && npm run test:evaluate-ci-repositories:tagged-release-release && npm run test:evaluate-ci-repositories:nightly-deploy-pr && npm run test:evaluate-ci-repositories:nightly-deploy-merge && npm run test:evaluate-ci-repositories:nightly-deploy-scheduled && npm run test:evaluate-ci-repositories:nightly-deploy-release && npm run test:evaluate-ci-render && npm run test:evaluate-pr-mcp && npm run test:evaluate-pr-api && npm run test:evaluate-pr-suite && npm run test:evaluate-pr-workflow && npm run test:evaluate-pr-tool-use && npm run test:evaluate-pr-promptfoo && npm run test:evaluate-pr-ai-feature && npm run test:evaluate-pr-test-review && npm run test:evaluate-pr-gap-loop && npm run test:evaluate-pr-learn && npm run test:evaluate-pr-tutorial && npm run test:evaluate-partitions && npm run test:evaluate-partition-plans-views-and-check && npm run test:evaluate-partition-plans-preflight-and-run && npm run test:evaluate-partition-plans-score && npm run test:evaluate-partition-plans-attempts-seal-and-mappings && npm run test:evaluate-partition-plans-attempts-records && npm run test:evaluate-partition-plans-attempts-gameability && npm run test:evaluate-interpret && npm run test:evaluate-calibration && npm run test:evaluate-boundaries && npm run test:evaluate-preflight && npm run test:evaluate-isolation-conformance && npm run test:evaluate-mutation:qualification-basics && npm run test:evaluate-mutation:qualification-guards && npm run test:evaluate-mutation:recovery && npm run test:evaluate-mutation:journals && npm run test:evaluate-run && npm run test:evaluate-progress && npm run test:evaluate-aggregate && npm run test:evaluate-confinement && npm run test:evaluate-confinement-audit && npm run test:evaluate-confinement-history && npm run test:evaluate-confinement-git-state && npm run test:evaluate-confinement-network && npm run test:evaluate-held-inputs && npm run test:evaluate-arms-historical && npm run test:evaluate-arms-deployments && npm run test:evaluate-evaluators && npm run test:evaluate-evaluators-agent-version && npm run test:evaluate-agents && npm run test:evaluate-agents-importers && npm run test:evaluate-agents-sealed-brief && npm run test:evaluate-held-attempts && npm run test:evaluate-private && npm run test:evaluate-records && npm run test:evaluate-mcp && npm run test:evaluate-api && npm run test:evaluate-workflow && npm run test:evaluate-tool-use && npm run test:evaluate-promptfoo && npm run test:evaluate-learned-framework && npm run test:docs-tutorial && npm run test:knowledge && npm run test:criteria-fragments && npm run test:doc-count-sources && npm run test:planning-doc-sources && npm run test:doc-counts && npm run test:doc-claim-sources && npm run test:doc-claims && npm run test:doc-invocation-entry && npm run test:doc-invocations && npm run test:doc-link-anchors && npm run test:docs-build-names && npm run test:docs-evaluate-sidebar && npm run test:docs-gap-reader && npm run test:enforce-hook && npm run test:framework-scaffold && npm run test:isolation-primitives && npm run test:atdd-isolation && npm run test:atdd-net-guard && npm run test:atdd-scoring && npm run test:atdd-workflow-guidance && npm run test:generation-healing && npm run test:framework-scaffold-install-isolation && npm run test:transcript-harness && npm run test:suite-manifest && npm run test:teach-me-testing-scoring && npm run test:eval-data && npm run test:eval-atdd-data && npm run test:eval-ci-data && npm run test:eval-framework-scaffold-data && npm run test:eval-nfr-data && npm run test:nfr-validate-corpus && npm run test:nfr-evidence-guidance && npm run test:eval-test-design-data && npm run test:eval-trace-data && npm run test:eval-routing-data && npm run test:eval-routing-boundaries && npm run test:eval-routing-evidence && npm run test:eval-transcript-data && npm run test:eval-teach-me-testing-data && npm run test:eval-schemas && npm run test:eval-diagnostics && npm run test:eval-replay && npm run test:eval-quality-corpus && npm run test:schema-versions && npm run test:contract-sources && npm run test:contracts && npm run test:contract-oracles && npm run test:probe-sources && npm run test:test-design-qualification && npm run test:test-review-qualification && npm run test:trace-qualification && npm run test:nfr-qualification && npm run test:ci-qualification && npm run test:probe-corpus && npm run test:compare-dominance && npm run test:compare-eval-runs && npm run test:trial-set-scoring && npm run test:automate-cli && npm run test:automate-generation-evidence && npm run test:automate-eval-fixture && npm run test:eval-automate-data && npm run test:clock-port && npm run test:probe-conformance && npm run test:corpus-conformance && npm run test:file-system-conformance && npm run test:file-system-port && npm run test:probe-targets && npm run test:port-totality && npm run test:ci-coverage && npm run test:ci-coverage-filters && npm run test:install-actionlint && npm run test:workflows-lint && npm run test:install-linux-sandbox && npm run test:shards && npm run test:groups && npm run test:cli && npm run test:workflow-cli && npm run test:test-review-pr-scope && npm run test:test-review-report && npm run test:test-review-rubric && npm run test:bmad-output-gated && npm run test:release-metadata && npm run test:release-notes && npm run test:lockfile-age && npm run test:lockfile-age-cache && npm run test:licences && npm run test:supply-chain && npm run test:boundary && npm run test:direction && npm run test:lineage && npm run test:guard-publish && npm run test:layering-boundary-lineage && npm run test:changelog && npm run test:tea-workflow-descriptions && npm run test:docs-mermaid && npm run test:llms-headroom && npm run validate:schemas && npm run lint && npm run lint:md && npm run format:check",
     "test:atdd-isolation": "node test/test-atdd-isolation.js",
     "test:atdd-net-guard": "node test/test-atdd-net-guard.js",
     "test:atdd-scoring": "node test/test-atdd-scoring.js",
@@ -263,6 +264,7 @@
     "test:trace-qualification": "node test/test-trace-qualification.js",
     "test:transcript-harness": "node test/test-transcript-harness.js",
     "test:trial-set-scoring": "node test/test-trial-set-scoring.js",
+    "test:workflow-cli": "node test/test-workflow-cli.js",
     "test:workflows-lint": "node test/test-workflows-lint.js",
     "validate:schemas": "node tools/validate-agent-schema.js"
   },

package/skills/bmad-testarch-test-design/steps-c/step-03-risk-and-testability.md

@@ -62,9 +62,15 @@ Using `risk-governance.md` and `probability-impact.md` (if loaded):
 - Identify real risks (not just features)
 - Ground every risk in an explicit statement from the supplied epic or a named artifact loaded for this run. Record the supporting statement in the risk description or mitigation notes so another reader can trace the row.
 - Keep the register bounded by the scope supported by the supplied epic or a named artifact loaded for this run. Do not add plausible risks merely because they are common in other systems. If a concern has no supporting statement, record it as an assumption or clarification outside the risk register.
+- Treat controls explicitly described as already satisfied as scope constraints. Verify them with regression assertions in the coverage plan. A hypothetical implementation violating a stated read-only, local-only, privacy, or rollout constraint needs evidence of a new exposure before it becomes a scored risk.
+- Consolidate conditions that share a failure mechanism, consequence, and mitigation into one risk. Keep individual trigger and boundary cases in the coverage plan. For example, a stale cached timestamp and a missed refresh event can be one display-freshness risk; absent-value and disabled-flag rendering can share one conditional-visibility risk when the same visibility guard controls both.
+- Preserve the risk table columns `Risk ID`, `Category`, `Description`, `Probability`, `Impact`, and `Score`. Add a separate source-evidence column when useful. State the failure consequence in `Description` and cite the supporting input.
+- Assign unique canonical IDs `R-001`, `R-002`, and so on. Preserve those IDs in coverage, mitigations, summaries, and handoffs. Keep epic or story identity in the document run key.
+- Preserve explicit score ranges in risk-band headings: high score 6 or greater, medium score 3 to 4, and low score 1 to 2. For a band with no identified risk, state that absence outside the table and leave its table body empty.
 - Classify by category: TECH / SEC / PERF / DATA / BUS / OPS
 - Score Probability (1–3) and Impact (1–3)
 - Calculate Risk Score (P × I)
+- Put only a single bare integer in each Probability, Impact, and Score table cell. Keep likelihood and consequence explanations in the Description, Mitigation, or nearby prose. A cell such as `2: possible boundary error` is invalid even when its leading number is in range.
 - Flag high risks (score ≥ 6)
 - Define mitigation, owner, and timeline
 

package/skills/bmad-testarch-test-design/steps-c/step-04-coverage-plan.md

@@ -46,6 +46,7 @@ For each requirement or risk-driven scenario:
 - Assign priorities (P0–P3) using `test-priorities-matrix.md`
 - Map NFR-derived risks to planned validation scenarios and evidence sources
 - Use the exact `Risk ID` assigned in the risk register in every `Risk Link` cell. A prose description alone is not a traceable mapping.
+- Each `Test Level` cell contains exactly one canonical value: E2E, API, Component, Integration, or Unit. Put performance, operational, device, and other qualifiers in scenario descriptions or notes.
 - Give every material risk at least one coverage row whose `Test Level` is suitable for that risk under `test-levels-framework.md`. Explain the suitability in the row notes when the level is not obvious. Preserve the risk ID when rows are split across priorities or test levels.
 
 **Priority rules:** decide each priority on business impact, user reach, and workaround
@@ -57,6 +58,8 @@ Walk the Priority Decision Tree in `test-priorities-matrix.md` for each scenario
 - P2: Secondary behavior with narrower user reach and an acceptable workaround
 - P3: Rare, cosmetic, or experimental behavior with minimal impact and an easy workaround
 
+Record the failure consequence and the source-supported workaround in the primary coverage row's notes. Preserve these four priority criteria in the published plan. Evaluate a performance budget or an operational control through its documented business consequence before assigning its test priority. Assess a workaround against the original failure consequence, before proposed mitigations. A valid workaround preserves essential business operation and resolves the affected state. Pausing the application, leaving a core user action unresolved, or suppressing a symptom needs a source-backed recovery path before it can justify a lower priority. Record the evidence for recoverability; mark it unresolved when the source provides none. Separate an acceptance threshold from the consequence of missing it. For a latency or throughput target, state whether the source establishes a critical business deadline, permanent loss, blocked essential operation, or bounded degradation while work remains recoverable. Record an unstated business consequence as a clarification. Assign P0 when the documented consequence meets the critical-impact criterion. A release acceptance target can still have P1 coverage when the documented consequence is material degradation. An empty priority band is valid; explain why the planned scenarios belong to the assigned bands. When every primary risk has the same priority, justify how each consequence meets that criterion.
+
 ---
 
 ## 2. NFR Coverage and Evidence Plan

package/skills/bmad-testarch-test-design/steps-c/step-05-generate-output.md

@@ -185,7 +185,8 @@ Before finalizing, review the complete output document for quality:
 1. **Remove duplication**: Progressive-append workflow may have created repeated sections — consolidate
 2. **Verify consistency**: Ensure terminology, risk scores, and references are consistent throughout
 3. **Check completeness**: All template sections should be populated or explicitly marked N/A
-4. **Format cleanup**: Ensure markdown formatting is clean (tables aligned, headers consistent, no orphaned references)
+4. **Table schema**: Preserve the canonical risk and coverage column names from the templates. Verify every scored risk has one unique `R-<three digits>` ID, every coverage link preserves that exact ID, and every risk-band heading states its score range. Probability, Impact, and Score cells contain only bare integers; explain each judgment in prose and verify Score equals Probability × Impact. Empty bands contain no risk rows; describe the absence in prose outside the table. Keep each risk description readable and traceable to its source.
+5. **Format cleanup**: Ensure markdown formatting is clean (tables aligned, headers consistent, no orphaned references)
 
 ---
 

package/skills/bmod-tea/bmod.toml

@@ -2,7 +2,7 @@
 
 [bmod]
 code = "tea"
-version = "2.0.4-next.0"
+version = "2.0.4-next.1"
 update_source = "github:bmad-code-org/bmad-method-test-architecture-enterprise/skills"
 skills = [
   "bmad-tea",