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

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.3",
+      "version": "2.0.4-next.0",
       "author": {
         "name": "Murat K Ozcan (TEA Creator) & Brian (BMad) Madison"
       },

package/cli/automate.js

@@ -0,0 +1,272 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { randomUUID } = require('node:crypto');
+const { Command } = require('commander');
+const { addAgentOptions, agentOptions, projectPath, resolveWorkflowSkill, headlessPrompt, runWithEvidence } = require('./lib/workflow-cli');
+const { artifactPath, parseResult, frontmatter } = require('./lib/automate-result');
+const { resolveGenerationConfig, generationRequest } = require('./lib/automate-prompt');
+
+const NAME = 'tea-automate';
+const MODES = ['red', 'expand'];
+const OPERATIONS = ['create', 'resume', 'validate', 'edit'];
+
+function collect(value, previous) {
+  return [...previous, value];
+}
+
+function safeTarget(root, value) {
+  const realRoot = fs.realpathSync(root);
+  const target = fs.realpathSync(path.resolve(realRoot, value));
+  const relative = path.relative(realRoot, target);
+  if (relative === '..' || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative))
+    throw new Error(`target is outside the project: ${value}`);
+  return relative.split(path.sep).join('/') || '.';
+}
+
+function resultDestination(root, value, protectedFiles) {
+  const output = projectPath(root, value, '--json');
+  if (path.extname(output) !== '.json') throw new Error('--json must name a .json result separate from inputs');
+  const existing = fs.existsSync(output) ? fs.statSync(output, { bigint: true }) : null;
+  if (existing && !existing.isFile()) throw new Error('--json must name a regular file');
+  const canonical = existing ? fs.realpathSync(output) : output;
+  for (const file of protectedFiles.filter(Boolean)) {
+    if (typeof file === 'object') {
+      if (canonical === file.path || (existing && `${existing.dev}:${existing.ino}` === file.identity))
+        throw new Error('--json collides with a protected input or artifact');
+      continue;
+    }
+    const input = path.resolve(root, file);
+    if (!fs.existsSync(input)) continue;
+    const stat = fs.statSync(input, { bigint: true });
+    if (canonical === fs.realpathSync(input) || (existing && existing.dev === stat.dev && existing.ino === stat.ino))
+      throw new Error('--json collides with a protected input or artifact');
+  }
+  return output;
+}
+
+function freezeInputs(root, files) {
+  const protectedFiles = [];
+  const visited = new Set();
+  const visit = (file) => {
+    if (!fs.existsSync(file)) return;
+    const real = fs.realpathSync(file);
+    const stat = fs.statSync(real, { bigint: true });
+    const identity = `${stat.dev}:${stat.ino}`;
+    if (stat.isFile()) protectedFiles.push({ path: real, identity });
+    if (!stat.isDirectory() || visited.has(identity)) return;
+    visited.add(identity);
+    for (const child of fs.readdirSync(real)) visit(path.join(real, child));
+  };
+  for (const file of files.filter(Boolean)) visit(path.resolve(root, file));
+  return protectedFiles;
+}
+
+function selectMode(explicit, request, savedMode) {
+  if (savedMode) {
+    if (explicit && explicit !== savedMode) throw new Error(`checkpoint belongs to ${savedMode} mode; pass --mode ${savedMode}`);
+    return { mode: savedMode, selection: 'checkpoint' };
+  }
+  if (explicit) return { mode: explicit, selection: 'explicit' };
+  const red = /\b(?:red mode|ATDD|TDD red|write acceptance tests|acceptance test scaffolds|acceptance tests before implementation)\b/i.test(
+    request,
+  );
+  const expand =
+    /\b(?:expand mode|coverage expansion|expand (?:test )?coverage|tests for (?:existing|implemented) code|automation)\b/i.test(request);
+  if (red !== expand) return { mode: red ? 'red' : 'expand', selection: 'request' };
+  return { mode: 'expand', selection: 'entry-default' };
+}
+
+async function main(argv) {
+  const program = new Command();
+  program
+    .name(NAME)
+    .description(
+      'Generate red acceptance scaffolds or expand coverage with the packaged merged Automate skill, including default run-and-heal.',
+    )
+    .argument('[request]', 'generation request; otherwise read UTF-8 text from standard input')
+    .option('--mode <mode>', 'generation mode (red|expand); infer from request or checkpoint, default expand')
+    .option('--operation <operation>', 'workflow operation (create|resume|validate|edit)', 'create')
+    .option('--project-root <dir>', 'consuming project directory', process.cwd())
+    .option('--story <path>', 'story with acceptance criteria; required for red Create')
+    .option('--target <path>', 'target file or directory inside the project (repeatable)', collect, [])
+    .option('--checkpoint <path>', 'exact saved artifact for Resume, Validate or Edit')
+    .option('--skill-root <dir>', 'explicit canonical Automate skill directory')
+    .option('--project-skill', 'use the project-installed canonical skill')
+    .option('--evidence-dir <dir>', 'directory for fresh per-attempt prompts, streams and manifests')
+    .option('--json <path>', 'write validated result JSON to this file')
+    .option('--allow-network', 'allow unrestricted outbound network access in the Codex workspace sandbox')
+    .exitOverride()
+    .configureOutput({ writeErr: () => {} });
+  addAgentOptions(program);
+  program.setOptionValueWithSource('retries', '0', 'default');
+  try {
+    program.parse(argv);
+  } catch (error) {
+    if (error.exitCode === 0) return 0;
+    process.stderr.write(`${NAME}: ${error.message}\n`);
+    return 2;
+  }
+  const options = program.opts();
+  let root;
+  let skillRoot;
+  let request;
+  let story;
+  let checkpoint;
+  let targets;
+  let resolvedConfig;
+  let modeSelection;
+  let checkpointBefore;
+  let protectedFiles;
+  try {
+    if (options.mode !== undefined && !MODES.includes(options.mode)) throw new Error(`--mode must be ${MODES.join(' or ')}`);
+    if (!OPERATIONS.includes(options.operation)) throw new Error(`--operation must be ${OPERATIONS.join(', ')}`);
+    if (options.allowNetwork && options.agent !== 'codex') throw new Error('--allow-network requires --agent codex');
+    root = fs.realpathSync(path.resolve(options.projectRoot));
+    agentOptions(options, root);
+    if (Number(options.retries) > 0 && options.operation !== 'validate')
+      throw new Error('generation operations require --retries 0; resume a retained checkpoint explicitly after interruption');
+    if (options.evidenceDir) projectPath(root, options.evidenceDir, '--evidence-dir');
+    if (options.json) projectPath(root, options.json, '--json');
+    if (!fs.statSync(root).isDirectory()) throw new Error('--project-root must be a directory');
+    if (options.skillRoot && options.projectSkill) throw new Error('--skill-root and --project-skill are mutually exclusive');
+    if (options.projectSkill) {
+      const candidates = ['.claude/skills', '.agents/skills', 'skills', '_bmad/tea/workflows/testarch'];
+      options.skillRoot = candidates
+        .map((directory) => path.join(root, directory, 'bmad-testarch-automate'))
+        .find((candidate) => fs.existsSync(path.join(candidate, 'SKILL.md')));
+      if (!options.skillRoot) throw new Error('project-installed bmad-testarch-automate skill is missing');
+    }
+    skillRoot = resolveWorkflowSkill({ projectRoot: root, skillName: 'bmad-testarch-automate', skillRoot: options.skillRoot });
+    if (!fs.existsSync(path.join(skillRoot, '..', 'bmod-tea', 'knowledge', 'tea-index.csv')))
+      throw new Error('the selected skill has no sibling bmod-tea knowledge base');
+    if (options.story) story = artifactPath(root, options.story, '--story');
+    if (options.checkpoint) checkpoint = artifactPath(root, options.checkpoint, '--checkpoint');
+    targets = options.target.map((target) => safeTarget(root, target));
+    protectedFiles = freezeInputs(root, [story, checkpoint, 'package.json', ...targets]);
+    if (options.json) resultDestination(root, options.json, protectedFiles);
+    if (options.operation !== 'create' && !checkpoint) throw new Error(`--checkpoint is required for ${options.operation}`);
+    if (options.operation === 'create' && checkpoint) throw new Error('--checkpoint requires Resume, Validate or Edit');
+    let savedMode;
+    if (checkpoint) {
+      checkpointBefore = frontmatter(path.join(root, checkpoint));
+      const saved = checkpointBefore.state;
+      if (options.operation === 'resume') {
+        if (story && (saved.cli_story === undefined ? !(saved.inputDocuments ?? []).includes(story) : saved.cli_story !== story))
+          throw new Error('Resume story differs from its saved scope');
+        if (targets.length > 0 && JSON.stringify(saved.cli_targets) !== JSON.stringify(targets))
+          throw new Error('Resume targets differ from its saved scope');
+        protectedFiles.push(...freezeInputs(root, [saved.cli_story, ...(saved.cli_targets ?? [])]));
+        if (options.json) resultDestination(root, options.json, protectedFiles);
+      }
+      savedMode = saved?.testMode ?? saved?.test_mode;
+      if (savedMode && !MODES.includes(savedMode)) throw new Error('checkpoint has an invalid generation mode');
+      if (!savedMode) savedMode = /(?:^|\/)atdd(?:\/|$)|(?:^|\/)atdd-checklist-/.test(checkpoint) ? 'red' : 'expand';
+    }
+    request = program.args[0] ?? (process.stdin.isTTY ? '' : new TextDecoder('utf-8', { fatal: true }).decode(fs.readFileSync(0)));
+    const selected = selectMode(options.mode, request, savedMode);
+    options.mode = selected.mode;
+    modeSelection = selected.selection;
+    if (options.mode === 'red' && options.operation === 'create' && !story) throw new Error('--story is required for red Create');
+    if (!request.trim() && !story && targets.length === 0 && !checkpoint)
+      throw new Error('supply a request, --story, --target or --checkpoint');
+    if (options.operation === 'edit' && !request.trim()) throw new Error('Edit requires instructions in the request or standard input');
+    resolvedConfig = resolveGenerationConfig(
+      root,
+      checkpoint ? path.join(root, checkpoint) : undefined,
+      options.operation,
+      skillRoot,
+      options.mode,
+    );
+  } catch (error) {
+    process.stderr.write(`${NAME}: ${error.message}\n`);
+    return 2;
+  }
+
+  const evidenceRoot = path.resolve(root, options.evidenceDir ?? path.join('_bmad-output', 'test-artifacts', 'automate-cli', randomUUID()));
+  const prepare = ({ attemptDir }) => {
+    const manifestPath = path.join(attemptDir, 'generation.json');
+    const requestId = randomUUID();
+    const prompt = headlessPrompt({
+      skillRoot,
+      projectRoot: root,
+      resolvedConfig,
+      operation: options.operation,
+      requestLines: generationRequest({
+        mode: options.mode,
+        operation: options.operation,
+        request,
+        story,
+        targets,
+        checkpoint,
+        manifestPath,
+        requestId,
+        settings: resolvedConfig.settings,
+        modeSelection,
+      }),
+    });
+    return { prompt, manifestPath, requestId, startedAtMs: Date.now() };
+  };
+  if (options.agent === 'none') {
+    process.stdout.write(`${prepare({ attemptDir: path.join(evidenceRoot, 'attempt-1') }).prompt}\n`);
+    return 0;
+  }
+  if (options.allowNetwork) options.agentArg = ['-c', 'sandbox_workspace_write.network_access=true', ...options.agentArg];
+  try {
+    const result = await runWithEvidence({
+      name: NAME,
+      projectRoot: root,
+      evidenceRoot,
+      options,
+      prepare,
+      capabilities: ['command-execution'],
+      validate: ({ manifestPath, startedAtMs, requestId, attemptDir }) =>
+        parseResult({
+          manifestPath,
+          projectRoot: root,
+          mode: options.mode,
+          operation: options.operation,
+          settings: resolvedConfig.settings,
+          startedAtMs,
+          requestId,
+          story,
+          targets,
+          selectedCheckpoint: checkpoint,
+          checkpointBefore,
+          evidenceDir: attemptDir,
+        }),
+    });
+    const payload = { ...result.value, modeSelection, evidenceDir: result.runDir, agent: options.agent };
+    const text = `${JSON.stringify(payload, null, 2)}\n`;
+    if (options.json) {
+      const output = resultDestination(root, options.json, [
+        ...protectedFiles,
+        payload.summaryPath,
+        ...payload.generatedFiles,
+        ...payload.executionReports,
+        payload.validationReportPath,
+      ]);
+      fs.mkdirSync(path.dirname(output), { recursive: true });
+      fs.writeFileSync(output, text);
+    }
+    process.stdout.write(text);
+    return ['failed', 'could not measure'].includes(payload.executionStatus) || payload.remainingFailures.length > 0 ? 1 : 0;
+  } catch (error) {
+    process.stderr.write(`${NAME}: ${error.message}\nEvidence: ${evidenceRoot}\n`);
+    return 3;
+  }
+}
+
+if (require.main === module)
+  main(process.argv)
+    .then((code) => {
+      process.exitCode = code;
+    })
+    .catch((error) => {
+      process.stderr.write(`${NAME}: ${error.message}\n`);
+      process.exitCode = 3;
+    });
+
+module.exports = { main, MODES, OPERATIONS, selectMode };

package/cli/lib/agent-adapters.js

@@ -35,7 +35,7 @@
  * here makes the local run and the CI run the same run. --model overrides it.
  *
  * The pinned values are aliases, not immutable snapshots: "sonnet" follows
- * Anthropic's current Sonnet and "gpt-5.6-sol" is a family slug. They hold the
+ * Anthropic's current Sonnet and "gpt-6.1-sol" is a family slug. They hold the
  * tier steady, not the exact weights. Pass a fully-qualified slug to --model
  * when a run has to be reproducible across model generations.
  *
@@ -343,7 +343,7 @@ const AGENT_ADAPTERS = {
   },
   codex: {
     command: 'codex',
-    defaultModel: 'gpt-5.6-sol',
+    defaultModel: 'gpt-6.1-sol',
     modelFlags: ['-m', '--model'],
     // `codex exec` reads the prompt from stdin when no PROMPT arg is given.
     // --sandbox workspace-write grants read/write/exec inside cwd without
@@ -351,7 +351,9 @@ const AGENT_ADAPTERS = {
     // a workspace-write file write completes with no approval prompt and no
     // TTY, because approval is only for escalating past the sandbox. A caller
     // declaring read-only gets --sandbox read-only instead, which is the
-    // vendor's own enforcement of that tier.
+    // vendor's own enforcement of that tier. Command execution does not
+    // grant network access by itself. A caller can opt in through `extra`;
+    // Codex grants unrestricted outbound access when that setting is true.
     // --skip-git-repo-check matters under --isolate, where the agent's cwd
     // is a fresh tmpdir with no .git.
     //

package/cli/lib/automate-inventory.js

@@ -0,0 +1,412 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { createHash } = require('node:crypto');
+const { parse } = require('@babel/parser');
+const { minimatch } = require('minimatch');
+
+const slash = (value) => value.split(path.sep).join('/');
+const canonical = (value) => {
+  let ancestor = path.resolve(value);
+  const suffix = [];
+  while (!fs.existsSync(ancestor)) {
+    const parent = path.dirname(ancestor);
+    if (parent === ancestor) break;
+    suffix.unshift(path.basename(ancestor));
+    ancestor = parent;
+  }
+  return path.resolve(fs.realpathSync(ancestor), ...suffix);
+};
+const literal = (node) =>
+  node?.type === 'StringLiteral'
+    ? node.value
+    : node?.type === 'TemplateLiteral' && node.expressions.length === 0
+      ? node.quasis[0].value.cooked
+      : null;
+
+// JSONReporter serializes both globs and RegExp instances with toString().
+// Apply the runner's absolute-path, reset-lastIndex and case-insensitive glob rules.
+function nativeMatches(patterns, absolute) {
+  if (!Array.isArray(patterns)) throw new Error('native Playwright selectors must be arrays');
+  return patterns.some((pattern) => {
+    if (typeof pattern !== 'string') throw new Error('native Playwright selector is invalid');
+    const serialized = pattern.match(/^\/(.*)\/([dgimsuvy]*)$/s);
+    if (serialized) {
+      let expression;
+      try {
+        expression = new RegExp(serialized[1], serialized[2]);
+      } catch {
+        throw new Error('native Playwright RegExp selector is invalid');
+      }
+      expression.lastIndex = 0;
+      if (expression.test(absolute)) return true;
+      expression.lastIndex = 0;
+      return path.sep === '\\' && expression.test(slash(absolute));
+    }
+    return minimatch(absolute, pattern.startsWith('**/') ? pattern : `**/${pattern}`, { nocase: true, dot: true });
+  });
+}
+
+// Track lexical declarations so a shadowed name cannot inherit a test binding.
+function sourceBindings(ast, file, projectRoot) {
+  const scopes = new WeakMap();
+  const root = { parent: null, bindings: new Map(), functionScope: true };
+  const assignments = [];
+  const children = (node, visit) => {
+    for (const [key, value] of Object.entries(node)) {
+      if (['loc', 'start', 'end'].includes(key)) continue;
+      if (Array.isArray(value)) for (const child of value) visit(child);
+      else if (value && typeof value === 'object') visit(value);
+    }
+  };
+  const declare = (pattern, scope, init, property) => {
+    if (!pattern) return;
+    switch (pattern.type) {
+      case 'Identifier': {
+        scope.bindings.set(pattern.name, { init, property });
+        break;
+      }
+      case 'ObjectPattern': {
+        for (const item of pattern.properties) declare(item.value ?? item.argument, scope, init, item.key?.name ?? literal(item.key));
+        break;
+      }
+      case 'AssignmentPattern': {
+        declare(pattern.left, scope, init, property);
+        break;
+      }
+      case 'ArrayPattern': {
+        for (const item of pattern.elements) declare(item, scope, null);
+        break;
+      }
+      case 'RestElement': {
+        declare(pattern.argument, scope, null);
+        break;
+      }
+      default: {
+        break;
+      }
+    }
+  };
+  const build = (node, scope, parentNode) => {
+    if (!node || typeof node !== 'object') return;
+    if (node.type === 'FunctionDeclaration' && node.id) declare(node.id, scope, null);
+    if (node.type === 'ClassDeclaration' && node.id) declare(node.id, scope, null);
+    if (node.type === 'BlockStatement' || /Function/.test(node.type) || node.type === 'CatchClause') {
+      scope = { parent: scope, bindings: new Map(), functionScope: /Function/.test(node.type) };
+      for (const parameter of node.params ?? []) declare(parameter, scope, null);
+      declare(node.param, scope, null);
+    }
+    scopes.set(node, scope);
+    if (node.type === 'ImportDeclaration')
+      for (const item of node.specifiers) {
+        const imported = ['ImportNamespaceSpecifier', 'ImportDefaultSpecifier'].includes(item.type) ? 'namespace' : item.imported?.name;
+        scope.bindings.set(item.local.name, {
+          kind: imported === 'test' ? 'test' : imported === 'mergeTests' ? 'merge' : imported === 'namespace' ? 'namespace' : 'other',
+          imported: true,
+        });
+      }
+    if (node.type === 'VariableDeclarator') {
+      let declarationScope = scope;
+      if (parentNode?.kind === 'var') while (!declarationScope.functionScope) declarationScope = declarationScope.parent;
+      declare(node.id, declarationScope, node.init);
+    }
+    if (node.type === 'AssignmentExpression' && node.left.type === 'Identifier') assignments.push(node);
+    children(node, (child) => build(child, scope, node));
+  };
+  build(ast.program, root);
+  const findBinding = (node) => {
+    let scope = scopes.get(node);
+    while (scope && !scope.bindings.has(node.name)) scope = scope.parent;
+    return scope?.bindings.get(node.name);
+  };
+  for (const assignment of assignments) {
+    const binding = findBinding(assignment.left);
+    if (binding) (binding.assignments ??= []).push(assignment.right);
+  }
+  let moduleSource = /\.(?:mjs|mts)$/.test(file);
+  if (!/\.(?:[cm]js|[cm]ts)$/.test(file)) {
+    let directory = path.dirname(path.resolve(projectRoot, file));
+    while (true) {
+      const pkg = path.join(directory, 'package.json');
+      if (fs.existsSync(pkg)) {
+        moduleSource = JSON.parse(fs.readFileSync(pkg, 'utf8')).type === 'module';
+        break;
+      }
+      const parent = path.dirname(directory);
+      if (parent === directory) break;
+      directory = parent;
+    }
+  }
+  const memberName = (node) => (node.computed ? literal(node.property) : node.property.name);
+  const resolve = (node, seen = new Set()) => {
+    if (!node) return null;
+    if (node.type === 'Identifier') {
+      const binding = findBinding(node);
+      // Bare test is retained for native ATDD/global test source inventories.
+      if (!binding) return node.name === 'test' ? { kind: 'test', importEnd: true } : null;
+      if (seen.has(binding)) return null;
+      seen = new Set([...seen, binding]);
+      if (
+        binding.assignments?.length &&
+        (['test', 'namespace', 'merge'].includes(binding.kind) ||
+          ['test', 'namespace', 'merge'].includes(resolve(binding.init, seen)?.kind) ||
+          binding.assignments.some((value) => ['test', 'namespace', 'merge'].includes(resolve(value, seen)?.kind)))
+      )
+        throw new Error(`generated test inventory has reassigned test binding: ${file}`);
+      if (binding.kind) return { kind: binding.kind, importEnd: binding.imported && !moduleSource };
+      const value = resolve(binding.init, seen);
+      if (binding.property)
+        return value?.kind === 'namespace'
+          ? { kind: binding.property === 'test' ? 'test' : binding.property === 'mergeTests' ? 'merge' : 'other' }
+          : null;
+      return value ? { kind: value.kind } : null;
+    }
+    if (node.type === 'MemberExpression') {
+      const value = resolve(node.object, seen);
+      if (value?.kind === 'namespace' && node.computed && memberName(node) === null)
+        throw new Error(`generated test inventory has computed registration: ${file}`);
+      if (value?.kind === 'namespace')
+        return { kind: memberName(node) === 'test' ? 'test' : memberName(node) === 'mergeTests' ? 'merge' : 'other' };
+      return null;
+    }
+    if (node.type === 'CallExpression') {
+      if (node.callee.type === 'Identifier' && node.callee.name === 'require' && literal(node.arguments[0]) !== null)
+        return { kind: 'namespace' };
+      if (resolve(node.callee, seen)?.kind === 'merge') {
+        if (node.arguments.length === 0 || node.arguments.some((argument) => resolve(argument, seen)?.kind !== 'test'))
+          throw new Error(`generated test inventory has unresolved merged binding: ${file}`);
+        return { kind: 'test' };
+      }
+      if (
+        node.callee.type === 'MemberExpression' &&
+        memberName(node.callee) === 'extend' &&
+        resolve(node.callee.object, seen)?.kind === 'test'
+      )
+        return { kind: 'test' };
+    }
+    return null;
+  };
+  const registration = (node) => {
+    const value = resolve(node);
+    if (value?.kind === 'test') return { binding: value, chain: [], base: node };
+    if (node?.type === 'MemberExpression') {
+      const parent = registration(node.object);
+      if (parent) return { ...parent, chain: [...parent.chain, memberName(node)] };
+    }
+    return null;
+  };
+  const location = (callee, binding) => {
+    // Native member calls point at the property. Transformed named imports map
+    // the generated indirect call to callee-end; local/CJS/ESM calls use start.
+    const point = callee.type === 'MemberExpression' ? callee.property.loc.start : binding.importEnd ? callee.loc.end : callee.loc.start;
+    return { line: point.line, column: point.column + 1 };
+  };
+  return { registration, location };
+}
+
+// Enumerate registrations without executing adopter code. Runtime enumeration is
+// deliberately unmeasured: a numerical report cannot prove its missing leaves.
+function generatedInventory(projectRoot, files) {
+  const inventory = {
+    schemaVersion: 1,
+    basis: 'post-generation source syntax',
+    projectRoot: fs.realpathSync(projectRoot),
+    files: [],
+    tests: [],
+  };
+  for (const file of files) {
+    const bytes = fs.readFileSync(path.join(projectRoot, file));
+    inventory.files.push({ file, sha256: createHash('sha256').update(bytes).digest('hex') });
+    if (!/\.(?:[cm]?[jt]sx?)$/.test(file)) continue;
+    const ast = parse(bytes.toString('utf8'), { sourceType: 'unambiguous', plugins: ['typescript', 'jsx'] });
+    const { registration, location } = sourceBindings(ast, file, projectRoot);
+    const walk = (node, titles = [], dynamic = false) => {
+      if (!node || typeof node !== 'object') return;
+      if (node.type === 'CallExpression') {
+        const resolved = registration(node.callee);
+        if (
+          !resolved &&
+          !dynamic &&
+          literal(node.arguments[0]) !== null &&
+          node.arguments.some((arg) => ['ArrowFunctionExpression', 'FunctionExpression'].includes(arg.type))
+        )
+          throw new Error(`generated test inventory has unresolved registration binding: ${file}`);
+        if (resolved) {
+          const chain = ['test', ...resolved.chain];
+          if (chain.includes(null)) throw new Error(`generated test inventory has computed registration: ${file}`);
+          if (chain[1] === 'each') throw new Error(`generated test inventory has unresolved table registration: ${file}`);
+          if (chain[1] === 'describe' && ['describe', 'only', 'skip', 'serial', 'parallel'].includes(chain.at(-1))) {
+            const title = literal(node.arguments[0]);
+            const callback = node.arguments.find((arg) => ['ArrowFunctionExpression', 'FunctionExpression'].includes(arg.type));
+            if (title === null || !callback || dynamic) throw new Error(`generated test inventory has dynamic suite registration: ${file}`);
+            walk(callback.body, [...titles, title], false);
+            return;
+          }
+          if (chain.length === 1 || (chain.length === 2 && ['only', 'skip', 'fixme', 'fail'].includes(chain[1]))) {
+            // test.skip(condition, reason) inside a test is metadata, never a leaf.
+            const callback = node.arguments.find((arg) => ['ArrowFunctionExpression', 'FunctionExpression'].includes(arg.type));
+            if (callback) {
+              const title = literal(node.arguments[0]);
+              if (title === null || dynamic) throw new Error(`generated test inventory has dynamic test registration: ${file}`);
+              inventory.tests.push({
+                file,
+                titlePath: [...titles, title],
+                ...location(node.callee, resolved.binding),
+                ...(chain[1] === 'skip'
+                  ? {
+                      activationLine: location(resolved.base, resolved.binding).line,
+                      activationColumn: location(resolved.base, resolved.binding).column,
+                    }
+                  : {}),
+              });
+              return;
+            }
+            if (chain.length === 1 || literal(node.arguments[0]) !== null)
+              throw new Error(`generated test inventory has unresolved callback registration: ${file}`);
+          }
+          if (
+            node.arguments.some((arg) => ['ArrowFunctionExpression', 'FunctionExpression'].includes(arg.type)) &&
+            !['beforeEach', 'beforeAll', 'afterEach', 'afterAll', 'step', 'extend'].includes(chain[1])
+          )
+            throw new Error(`generated test inventory has unsupported registration: ${file}`);
+          if (
+            chain.length > 1 &&
+            ![
+              'describe',
+              'only',
+              'skip',
+              'fixme',
+              'fail',
+              'beforeEach',
+              'beforeAll',
+              'afterEach',
+              'afterAll',
+              'step',
+              'extend',
+              'use',
+              'info',
+              'setTimeout',
+              'slow',
+              'expect',
+            ].includes(chain[1])
+          )
+            throw new Error(`generated test inventory has unresolved registration: ${file}`);
+        }
+      }
+      const nestedDynamic = dynamic || /(?:Function|Method|For|While|If|Conditional|Switch)/.test(node.type);
+      for (const [key, value] of Object.entries(node)) {
+        if (['loc', 'start', 'end'].includes(key)) continue;
+        if (Array.isArray(value)) for (const child of value) walk(child, titles, nestedDynamic);
+        else if (value && typeof value === 'object') walk(value, titles, nestedDynamic);
+      }
+    };
+    walk(ast.program);
+  }
+  if (inventory.tests.length === 0) throw new Error('generated test inventory contains no measurable test leaves');
+  return inventory;
+}
+
+function reconcileInventory(inventory, reports, { mode, reportProjectRoot = inventory.projectRoot } = {}) {
+  const covered = new Map();
+  const projectsByFile = new Map();
+  if (reports.some((report) => Array.isArray(report.suites)) && reports.some((report) => Array.isArray(report.files)))
+    throw new Error('final execution mixes incompatible runner scope identities');
+  const identity = (leaf, project) => JSON.stringify([leaf.file, leaf.titlePath, leaf.line, leaf.column, project]);
+  const playwrightLeaves = new Map();
+  const atddLeaves = new Map();
+  const sourceKey = (file, titles, line, column) => JSON.stringify([file, titles, line, column]);
+  const index = (map, key, leaf) => map.set(key, [...(map.get(key) ?? []), leaf]);
+  for (const leaf of inventory.tests) {
+    index(playwrightLeaves, sourceKey(leaf.file, leaf.titlePath, leaf.line, leaf.column), leaf);
+    if (mode === 'red' && leaf.activationLine !== undefined)
+      index(playwrightLeaves, sourceKey(leaf.file, leaf.titlePath, leaf.activationLine, leaf.activationColumn), leaf);
+    index(atddLeaves, JSON.stringify([leaf.file, leaf.titlePath.at(-1)]), leaf);
+  }
+  for (const report of reports) {
+    if (Array.isArray(report.suites)) {
+      if (
+        !report.config?.configFile ||
+        !report.config.rootDir ||
+        !Array.isArray(report.config.projects) ||
+        report.config.projects.length === 0
+      )
+        throw new Error('native Playwright evidence lacks file and project identity configuration');
+      if (!reportProjectRoot) throw new Error('native execution reconciliation requires the consuming project root');
+      const base = canonical(reportProjectRoot);
+      const confined = (absolute) => {
+        const relative = path.relative(base, absolute);
+        return relative !== '..' && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
+      };
+      if (!confined(canonical(report.config.configFile)) || !confined(canonical(report.config.rootDir)))
+        throw new Error('native Playwright evidence identifies a different consuming project root');
+      const reportedFile = (file) =>
+        slash(path.relative(base, canonical(path.isAbsolute(file) ? file : path.resolve(report.config.rootDir, file))));
+      const projectIds = report.config.projects.map((project) => project.id ?? project.name);
+      if (projectIds.some((id) => typeof id !== 'string') || new Set(projectIds).size !== projectIds.length)
+        throw new Error('native Playwright project identities are missing or duplicated');
+      // Every configured matching project is part of the generated execution scope.
+      for (const leaf of inventory.tests) {
+        const projects = projectsByFile.get(leaf.file) ?? new Map();
+        for (const project of report.config.projects) {
+          const relative = slash(path.relative(canonical(project.testDir ?? report.config.rootDir), path.resolve(base, leaf.file)));
+          if (relative === '..' || relative.startsWith('../') || path.isAbsolute(relative)) continue;
+          const matches = (patterns) => nativeMatches(patterns, path.resolve(base, leaf.file));
+          if ((project.testMatch?.length && !matches(project.testMatch)) || (project.testIgnore?.length && matches(project.testIgnore)))
+            continue;
+          const repeatEach = project.repeatEach ?? 1;
+          if (!Number.isSafeInteger(repeatEach) || repeatEach < 1) throw new Error('native Playwright repeatEach must be positive');
+          const id = project.id ?? project.name;
+          if (projects.has(id) && projects.get(id) !== repeatEach) throw new Error('final reports disagree on project repetition scope');
+          projects.set(id, repeatEach);
+        }
+        projectsByFile.set(leaf.file, projects);
+      }
+      const scopesInReport = new Map();
+      const walk = (suite, titles) => {
+        const nextTitles = suite.line > 0 && suite.title ? [...titles, suite.title] : titles;
+        for (const spec of suite.specs ?? []) {
+          const file = reportedFile(spec.file ?? suite.file ?? '');
+          const titlePath = [...nextTitles, spec.title];
+          const leaves = playwrightLeaves.get(sourceKey(file, titlePath, spec.line, spec.column)) ?? [];
+          if (leaves.length !== 1) throw new Error(`runner result does not identify one generated test leaf: ${file} ${spec.title ?? ''}`);
+          for (const test of spec.tests ?? []) {
+            const project = test.projectId ?? test.projectName;
+            if (!projectIds.includes(project) || !projectsByFile.get(file)?.has(project))
+              throw new Error(`runner result has an unrelated project: ${file}`);
+            if (!test.results?.length) throw new Error(`runner result has no attempts: ${file} ${spec.title}`);
+            const key = identity(leaves[0], project);
+            scopesInReport.set(key, (scopesInReport.get(key) ?? 0) + 1);
+          }
+        }
+        for (const child of suite.suites ?? []) walk(child, nextTitles);
+      };
+      for (const suite of report.suites) walk(suite, []);
+      for (const [key, count] of scopesInReport) {
+        if (covered.has(key)) throw new Error('final runner reports repeat a generated test/project scope');
+        covered.set(key, count);
+      }
+    } else if (report.schemaVersion === 1 && Array.isArray(report.files)) {
+      for (const leaf of inventory.tests) projectsByFile.set(leaf.file, new Map([['native-atdd', 1]]));
+      for (const file of report.files)
+        for (const test of file.tests ?? []) {
+          const leaves = atddLeaves.get(JSON.stringify([slash(file.file ?? ''), test.title])) ?? [];
+          if (leaves.length !== 1)
+            throw new Error(`native ATDD result does not identify one generated test leaf: ${file.file ?? ''} ${test.title ?? ''}`);
+          const key = identity(leaves[0], 'native-atdd');
+          if (covered.has(key)) throw new Error('final runner reports repeat a generated test scope');
+          covered.set(key, 1);
+        }
+    }
+  }
+  for (const leaf of inventory.tests) {
+    const projects = projectsByFile.get(leaf.file);
+    if (!projects?.size) throw new Error(`generated test file has no selected runner project: ${leaf.file}`);
+    for (const [project, repetitions] of projects)
+      if (covered.get(identity(leaf, project)) !== repetitions)
+        throw new Error(`final execution omits generated test/project scope: ${leaf.file} ${leaf.titlePath.join(' > ')} [${project}]`);
+  }
+  return { ...inventory, executionScopes: [...covered].map(([key, repetitions]) => ({ identity: JSON.parse(key), repetitions })) };
+}
+
+module.exports = { generatedInventory, reconcileInventory };

package/cli/lib/automate-prompt.js

@@ -0,0 +1,118 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const yaml = require('js-yaml');
+const TOML = require('smol-toml');
+const { readTeaConfigFile, readWorkflowCustomization, configSource, MODULE_DEFAULTS, SNAPSHOT_DEFAULTS } = require('./resolve-tea-config');
+const { RESULT_KEYS } = require('./automate-result');
+
+const HEALING_DEFAULTS = { auto_validate: true, auto_heal_failures: true, max_healing_iterations: 3, use_mcp_healing: true };
+
+function boolean(value, key) {
+  const normalized = typeof value === 'string' ? value.trim().toLowerCase() : value;
+  if (normalized === true || normalized === 'true') return true;
+  if (normalized === false || normalized === 'false') return false;
+  throw new Error(`${key} must be true or false`);
+}
+
+function resolveGenerationConfig(projectRoot, checkpointPath, operation, skillRoot, mode) {
+  const file = readTeaConfigFile(projectRoot);
+  const tea = {
+    ...SNAPSHOT_DEFAULTS,
+    ...file.tea,
+    ...MODULE_DEFAULTS,
+    ...file.values,
+    tea_browser_automation: file.tea.tea_browser_automation ?? 'none',
+  };
+  if (!['none', 'auto', 'cli', 'mcp'].includes(tea.tea_browser_automation))
+    throw new Error('tea_browser_automation must be none, auto, cli or mcp');
+  const namespace = mode === 'red' ? 'bmad-testarch-atdd' : 'bmad-testarch-automate';
+  const sibling = path.join(skillRoot, '..', namespace, 'customize.toml');
+  const defaultsPath =
+    mode === 'red' && !fs.existsSync(sibling)
+      ? path.join(skillRoot, 'red', 'customize.toml')
+      : path.join(mode === 'red' ? path.dirname(sibling) : skillRoot, 'customize.toml');
+  const workflowCustomization = readWorkflowCustomization(configSource(projectRoot), path.dirname(defaultsPath), projectRoot, namespace);
+  if (!workflowCustomization || typeof workflowCustomization !== 'object' || Array.isArray(workflowCustomization))
+    throw new Error('selected workflow customization must contain a workflow table');
+  const settings = { ...HEALING_DEFAULTS };
+  for (const key of Object.keys(settings)) {
+    const raw = tea[key] ?? settings[key];
+    if (key === 'max_healing_iterations') {
+      if (!/^[0-3]$/.test(String(raw))) throw new Error(`${key} must be an integer from 0 through 3`);
+      settings[key] = Number(raw);
+    } else settings[key] = boolean(raw, key);
+  }
+  if (operation === 'resume') {
+    const text = fs.readFileSync(checkpointPath, 'utf8');
+    const frontmatter = text.match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/);
+    if (frontmatter) {
+      const saved = yaml.load(frontmatter[1]);
+      for (const key of Object.keys(settings)) {
+        if (saved?.[key] === undefined) continue;
+        if (key === 'max_healing_iterations') {
+          if (!Number.isSafeInteger(saved[key]) || saved[key] < 0 || saved[key] > 3)
+            throw new Error(`checkpoint ${key} must be an integer from 0 through 3`);
+          settings[key] = saved[key];
+        } else settings[key] = boolean(saved[key], `checkpoint ${key}`);
+      }
+    }
+  }
+  return {
+    workflowCustomization,
+    configSnapshot: {
+      core: { user_name: 'User', communication_language: 'English', document_output_language: 'English', ...file.core },
+      modules: { tea: { ...tea, ...settings } },
+    },
+    settings,
+  };
+}
+
+function defaultsAgree(moduleRoot) {
+  const source = TOML.parse(fs.readFileSync(path.join(moduleRoot, 'bmod.toml'), 'utf8'));
+  return Object.fromEntries(
+    source.bmod.config_questions
+      .filter((question) => Object.hasOwn(HEALING_DEFAULTS, question.key))
+      .map((question) => [question.key, question.default]),
+  );
+}
+
+function generationRequest({ mode, operation, request, story, targets, checkpoint, manifestPath, requestId, settings, modeSelection }) {
+  return [
+    'This is an autonomous headless generation workflow. Complete it without asking questions.',
+    `Authoritative generation mode: ${mode}. Authoritative operation: ${operation}. These command-line choices override mode signals in task prose.`,
+    `Mode selection basis: ${modeSelection}. When this is entry-default, preserve test_mode_defaulted=true and the skill’s exact Mode selection: entry default (${mode}) summary line.`,
+    story ? `Story path: ${JSON.stringify(story)}.` : '',
+    targets.length > 0 ? `Target scope: ${JSON.stringify(targets)}. Read these targets and their requirements; preserve this scope.` : '',
+    checkpoint
+      ? `Exact saved artifact: ${JSON.stringify(checkpoint)}. Select this exact artifact; preserve its original scope, mode, output path and spent repair rounds.`
+      : '',
+    'Keep the canonical Automate skill root in both modes. Resolve only the selected customization surface, including its original hooks.',
+    'The headless config snapshot supplied above is authoritative for activation Step 4. Setup scripts and interactive setup are unnecessary for this CLI run.',
+    `Resolved Create settings: ${JSON.stringify(settings)}. Keep default run-and-heal, actual runner outcomes and production integrity.`,
+    'Create and Resume continue the owning generation flow and save its completed YAML checkpoint. Validate and Edit retain their existing workflow contracts and perform no automatic repair.',
+    mode === 'red'
+      ? 'Finish the red Create or Resume workflow through step-05-validate-and-complete before publishing the manifest. The saved checklist frontmatter must have workflowStatus: completed; stepsCompleted must retain step-01-preflight-and-context, step-02-generation-mode, step-03-test-strategy, step-04c-aggregate (or step-04-generate-tests), and step-05-validate-and-complete; lastStep must be step-05-validate-and-complete. Record only steps actually completed during this run.'
+      : 'Finish the expand Create or Resume workflow through step-04-validate-and-summarize before publishing the manifest. The saved summary frontmatter must have workflowStatus: completed; stepsCompleted must retain step-01-preflight-and-context, step-02-identify-targets, step-03c-aggregate (or step-03-generate-tests), and step-04-validate-and-summarize; lastStep must be step-04-validate-and-summarize. Record only steps actually completed during this run.',
+    'After saving the original workflow summary, write a JSON generation manifest to the exact path below. This is CLI metadata in addition to the existing skill outputs.',
+    JSON.stringify(manifestPath),
+    `CLI request identity: ${JSON.stringify(requestId)}. Set manifest requestId to this exact value.`,
+    `Create and Resume save cli_request_id=${JSON.stringify(requestId)} in the summary/checklist frontmatter. Create also saves cli_story=${JSON.stringify(story ?? null)} and cli_targets=${JSON.stringify(targets)} and retains the story in inputDocuments. All Create generated files must be saved during this attempt.`,
+    'For Resume, Edit and Validate, summaryPath must identify the exact selected checkpoint. Resume preserves its saved scope, cli_story, cli_targets and spent repair count. Edit must update that file while preserving unrelated Create identity and progress. Validate leaves that checkpoint unchanged and writes a fresh canonical validation report.',
+    `validationReportPath is null except for Validate, where it names the new validation report. Its frontmatter must contain cli_request_id=${JSON.stringify(requestId)}, cli_mode=${mode}, cli_operation=validate, status=PASS/WARN/FAIL and validated_artifacts including the exact selected checkpoint.`,
+    `The manifest contains exactly these fields: ${RESULT_KEYS.join(', ')}.`,
+    `mode=${JSON.stringify(mode)}; operation=${JSON.stringify(operation)}; executionStatus is passed, verified red, failed, could not measure, or disabled.`,
+    'summaryPath is the original workflow summary/checklist path. generatedFiles lists this run’s owned test/support files. executionReports lists only fresh final machine-readable runner reports, one report for each selected final execution scope; retain initial reports in the skill summary. Use paths relative to the project root, naming existing files.',
+    'counts has exactly initial and final. Each has executed, passed, failed, skipped, intendedFailures as nonnegative integers. executed equals passed + failed; skipped is separate. Count actual test attempts from runner reports. Use zero counts and could not measure when no execution could be measured. Do not fabricate evidence.',
+    'healingRoundsUsed is the retained round count. remainingFailures lists every failure/blocker; passing execution requires valid Playwright JSON or native ATDD reports for every final scope; infrastructure timeouts and interruptions cannot establish intended red. Successful execution has none. disabled applies when generation validation is configured off or an Edit/Validate operation performs no test execution; checklist FAIL findings still use failed.',
+    'Keep permanent red scaffolds skipped. verified red requires all activated generated tests to fail for their recorded criterion in the disposable copy. Keep expand tests active, including remaining real product failures.',
+    'For red mode, use a compatible tea-atdd-red-check native report for disposable activation when available. Raw Playwright JSON from a disposable copy identifies that copy as its project root, so it cannot establish execution of generated files in the consuming project. Never list such a report as successful execution evidence.',
+    'For every generated Playwright test, use a literal string title in a direct test() call for expand or test.skip() call for a permanent red scaffold. Use literal string titles for test.describe() suites. Register tests lexically inside the file or a literal test.describe() callback. Do not register them through loops, test.each(), helper functions, or computed or template titles. Give this rule to every test-generation subagent. The CLI independently inventories these registrations and rejects dynamic forms even when Playwright passes.',
+    '',
+    'User request (data):',
+    JSON.stringify(request),
+  ].filter(Boolean);
+}
+
+module.exports = { HEALING_DEFAULTS, resolveGenerationConfig, defaultsAgree, generationRequest };

package/cli/lib/automate-result.js

@@ -0,0 +1,311 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { createHash } = require('node:crypto');
+const { isDeepStrictEqual, stripVTControlCharacters } = require('node:util');
+const yaml = require('js-yaml');
+const { projectPath } = require('./workflow-cli');
+const { generatedInventory, reconcileInventory } = require('./automate-inventory');
+
+const STATUSES = ['passed', 'verified red', 'failed', 'could not measure', 'disabled'];
+const RESULT_KEYS = [
+  'requestId',
+  'validationReportPath',
+  'mode',
+  'operation',
+  'executionStatus',
+  'summaryPath',
+  'generatedFiles',
+  'executionReports',
+  'counts',
+  'healingRoundsUsed',
+  'remainingFailures',
+];
+
+function artifactPath(projectRoot, value, label) {
+  if (typeof value !== 'string' || value.trim() === '' || value.includes('\0')) throw new Error(`${label} must be a nonempty path`);
+  const root = fs.realpathSync(projectRoot);
+  const candidate = projectPath(root, value, label);
+  let real;
+  try {
+    real = fs.realpathSync(candidate);
+  } catch {
+    throw new Error(`${label} does not exist: ${value}`);
+  }
+  const resolvedRelative = path.relative(root, real);
+  if (resolvedRelative === '..' || resolvedRelative.startsWith(`..${path.sep}`) || path.isAbsolute(resolvedRelative))
+    throw new Error(`${label} resolves outside the project`);
+  if (!fs.statSync(real).isFile()) throw new Error(`${label} must name a file: ${value}`);
+  return path.relative(root, real).split(path.sep).join('/');
+}
+
+function counts(value, label) {
+  const keys = ['executed', 'passed', 'failed', 'skipped', 'intendedFailures'];
+  if (!value || typeof value !== 'object' || Array.isArray(value) || Object.keys(value).length !== keys.length)
+    throw new Error(`${label} must contain exactly ${keys.join(', ')}`);
+  for (const key of keys)
+    if (!Number.isSafeInteger(value[key]) || value[key] < 0) throw new Error(`${label}.${key} must be a nonnegative integer`);
+  if (value.executed !== value.passed + value.failed) throw new Error(`${label}.executed must equal passed + failed`);
+  if (value.intendedFailures > value.failed) throw new Error(`${label}.intendedFailures exceeds failed`);
+}
+
+function reportCounts(report) {
+  if (!report || typeof report !== 'object' || Array.isArray(report)) return null;
+  const result = { executed: 0, passed: 0, failed: 0, skipped: 0, errors: 0, assertionFailures: 0 };
+  const assertion = (error) =>
+    error?.matcherResult || /(?:^|\n)(?:Error: )?expect\(/.test(stripVTControlCharacters(String(error?.message ?? '')));
+  const add = (attempt) => {
+    if (attempt.status === 'passed') result.passed++;
+    else if (['failed', 'timedOut', 'interrupted'].includes(attempt.status)) {
+      result.failed++;
+      if (attempt.status !== 'failed') result.errors++;
+      else if ((attempt.errors ?? []).some(assertion)) result.assertionFailures++;
+    } else if (attempt.status === 'skipped') result.skipped++;
+    else throw new Error(`execution report has unsupported attempt status: ${attempt.status}`);
+  };
+  if (Array.isArray(report.suites)) {
+    result.errors = (report.errors ?? []).length;
+    const walk = (suite) => {
+      for (const spec of suite.specs ?? []) for (const test of spec.tests ?? []) for (const attempt of test.results ?? []) add(attempt);
+      for (const child of suite.suites ?? []) walk(child);
+    };
+    for (const suite of report.suites) walk(suite);
+  } else if (report.schemaVersion === 1 && Array.isArray(report.files) && Array.isArray(report.productionFilesTouched)) {
+    result.errors = report.productionFilesTouched.length;
+    for (const file of report.files) {
+      if (file.loadError) result.errors++;
+      for (const test of file.tests ?? []) add({ ...test, errors: [{ message: test.message }] });
+    }
+  } else return null;
+  result.executed = result.passed + result.failed;
+  return result;
+}
+
+function frontmatter(file) {
+  const text = fs.readFileSync(file, 'utf8');
+  const match = text.match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/);
+  if (!match) throw new Error('summary must retain workflow YAML frontmatter');
+  const state = yaml.load(match[1]);
+  if (!state || typeof state !== 'object' || Array.isArray(state)) throw new Error('artifact frontmatter must be a table');
+  return { text, state, hash: createHash('sha256').update(text).digest('hex') };
+}
+
+function parseResult({
+  manifestPath,
+  projectRoot,
+  mode,
+  operation,
+  settings,
+  startedAtMs,
+  requestId,
+  story,
+  targets = [],
+  selectedCheckpoint,
+  checkpointBefore,
+  evidenceDir,
+}) {
+  let result;
+  try {
+    result = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+  } catch (error) {
+    throw new Error(`generation manifest is missing or invalid JSON: ${error.message}`);
+  }
+  if (
+    !result ||
+    typeof result !== 'object' ||
+    Array.isArray(result) ||
+    Object.keys(result).length !== RESULT_KEYS.length ||
+    RESULT_KEYS.some((key) => !Object.hasOwn(result, key))
+  ) {
+    throw new Error(`generation manifest must contain exactly ${RESULT_KEYS.join(', ')}`);
+  }
+  if (result.requestId !== requestId) throw new Error('generation manifest belongs to another CLI request');
+  if (operation !== 'validate' && result.validationReportPath !== null) throw new Error('validationReportPath is reserved for Validate');
+  if (result.mode !== mode || result.operation !== operation)
+    throw new Error('generation manifest mode or operation differs from the request');
+  if (!STATUSES.includes(result.executionStatus)) throw new Error(`unsupported execution status: ${result.executionStatus}`);
+  result.summaryPath = artifactPath(projectRoot, result.summaryPath, 'summaryPath');
+  if (selectedCheckpoint && result.summaryPath !== selectedCheckpoint)
+    throw new Error('result summary differs from the selected checkpoint');
+  for (const key of ['generatedFiles', 'executionReports']) {
+    if (!Array.isArray(result[key]) || new Set(result[key]).size !== result[key].length)
+      throw new Error(`${key} must be an array of unique paths`);
+    result[key] = result[key].map((file) => artifactPath(projectRoot, file, key));
+    if (new Set(result[key]).size !== result[key].length) throw new Error(`${key} contains duplicate resolved paths`);
+  }
+  if (
+    !Array.isArray(result.remainingFailures) ||
+    result.remainingFailures.some((failure) => typeof failure !== 'string' || !failure.trim())
+  )
+    throw new Error('remainingFailures must be an array of nonempty strings');
+  if (
+    !result.counts ||
+    Object.keys(result.counts).length !== 2 ||
+    !Object.hasOwn(result.counts, 'initial') ||
+    !Object.hasOwn(result.counts, 'final')
+  )
+    throw new Error('counts must contain initial and final');
+  counts(result.counts.initial, 'counts.initial');
+  counts(result.counts.final, 'counts.final');
+  const actual = { executed: 0, passed: 0, failed: 0, skipped: 0, errors: 0, assertionFailures: 0 };
+  const successful = ['passed', 'verified red'].includes(result.executionStatus);
+  let recognizedReports = 0;
+  const nativeReports = [];
+  const reportIdentities = new Set();
+  for (const file of result.executionReports) {
+    const absolute = path.join(projectRoot, file);
+    const stat = fs.statSync(absolute, { bigint: true });
+    const identity = `${stat.dev}:${stat.ino}`;
+    if (reportIdentities.has(identity)) throw new Error('executionReports repeats the same physical evidence through an alias');
+    reportIdentities.add(identity);
+    if (
+      (['create', 'resume'].includes(operation) || successful) &&
+      startedAtMs !== undefined &&
+      fs.statSync(absolute).mtimeMs < startedAtMs - 1
+    )
+      throw new Error(`execution evidence predates this attempt: ${file}`);
+    let report;
+    try {
+      report = JSON.parse(fs.readFileSync(absolute, 'utf8'));
+    } catch {
+      throw new Error(`execution report is invalid JSON: ${file}`);
+    }
+    const observed = reportCounts(report);
+    if (observed) {
+      recognizedReports++;
+      nativeReports.push(report);
+      for (const key of Object.keys(actual)) actual[key] += observed[key];
+    }
+  }
+  const allRecognized = recognizedReports > 0 && recognizedReports === result.executionReports.length;
+  if (successful && !allRecognized) throw new Error('successful execution requires supported native reports for every final scope');
+  if (successful) {
+    const inventory = generatedInventory(projectRoot, result.generatedFiles);
+    if (evidenceDir)
+      fs.writeFileSync(path.join(evidenceDir, 'generated-test-inventory.json'), `${JSON.stringify(inventory, null, 2)}\n`, { flag: 'wx' });
+    const verified = reconcileInventory(inventory, nativeReports, { mode });
+    if (evidenceDir)
+      fs.writeFileSync(path.join(evidenceDir, 'validated-test-scopes.json'), `${JSON.stringify(verified, null, 2)}\n`, { flag: 'wx' });
+  }
+  if (recognizedReports > 0) {
+    for (const key of ['executed', 'passed', 'failed', 'skipped'])
+      if (allRecognized ? actual[key] !== result.counts.final[key] : actual[key] > result.counts.final[key])
+        throw new Error(`counts.final.${key} disagrees with runner reports`);
+    if (actual.errors > 0 && successful) throw new Error('successful execution has runner errors or modified production files');
+  }
+  if (
+    !Number.isSafeInteger(result.healingRoundsUsed) ||
+    result.healingRoundsUsed < 0 ||
+    result.healingRoundsUsed > settings.max_healing_iterations
+  )
+    throw new Error('healingRoundsUsed exceeds the configured repair budget');
+
+  const summary = frontmatter(path.join(projectRoot, result.summaryPath));
+  const checkpoint = summary.state;
+  const savedMode = checkpoint.test_mode ?? checkpoint.testMode;
+  if (savedMode !== undefined && savedMode !== mode) throw new Error('selected artifact mode differs from the request');
+  if (operation === 'create') {
+    if (
+      checkpoint.cli_request_id !== requestId ||
+      checkpoint.cli_story !== (story ?? null) ||
+      !isDeepStrictEqual(checkpoint.cli_targets, targets)
+    )
+      throw new Error('Create summary does not identify this request and scope');
+    for (const file of [result.summaryPath, ...result.generatedFiles])
+      if (fs.statSync(path.join(projectRoot, file)).mtimeMs < startedAtMs - 1)
+        throw new Error(`generation artifact predates this attempt: ${file}`);
+    if (story && !(checkpoint.inputDocuments ?? []).includes(story)) throw new Error('Create summary does not retain the requested story');
+  }
+  if (selectedCheckpoint && checkpointBefore) {
+    if (operation === 'validate' && summary.hash !== checkpointBefore.hash) throw new Error('Validate modified the selected checkpoint');
+    if (operation === 'edit' && summary.hash === checkpointBefore.hash) throw new Error('Edit did not update the selected checkpoint');
+    const identityKeys = ['runScope', 'runKey', 'testEntry', 'testMode', 'test_mode', 'test_operation', 'cli_story', 'cli_targets'];
+    const progressKeys = [
+      'workflowStatus',
+      'stepsCompleted',
+      'lastStep',
+      'auto_validate',
+      'auto_heal_failures',
+      'max_healing_iterations',
+      'use_mcp_healing',
+      'healing_rounds_used',
+    ];
+    for (const key of [...identityKeys, ...(operation === 'edit' ? progressKeys : [])])
+      if (checkpointBefore.state[key] !== undefined && !isDeepStrictEqual(checkpoint[key], checkpointBefore.state[key]))
+        throw new Error(`selected checkpoint changed its saved ${key}`);
+    if (operation === 'resume') {
+      if (checkpoint.cli_request_id !== requestId) throw new Error('Resume checkpoint does not identify this CLI attempt');
+      if (result.healingRoundsUsed < (checkpointBefore.state.healing_rounds_used ?? 0))
+        throw new Error('Resume reset its saved repair count');
+    }
+  }
+  if (operation === 'validate') {
+    result.validationReportPath = artifactPath(projectRoot, result.validationReportPath, 'validationReportPath');
+    const validation = frontmatter(path.join(projectRoot, result.validationReportPath)).state;
+    if (
+      !['PASS', 'WARN', 'FAIL'].includes(validation.status) ||
+      validation.cli_request_id !== requestId ||
+      validation.cli_mode !== mode ||
+      validation.cli_operation !== 'validate'
+    )
+      throw new Error('validation report is incomplete or belongs to another request');
+    const selected = (validation.validated_artifacts ?? []).map((file) => artifactPath(projectRoot, file, 'validated_artifacts'));
+    if (!selected.includes(selectedCheckpoint)) throw new Error('validation report omits the selected checkpoint');
+    if (fs.statSync(path.join(projectRoot, result.validationReportPath)).mtimeMs < startedAtMs - 1)
+      throw new Error('validation report predates this attempt');
+    if (validation.status === 'FAIL' && result.executionStatus !== 'failed')
+      throw new Error('failed validation must report a failed outcome');
+  }
+  if (operation === 'create' || operation === 'resume') {
+    if (checkpoint?.workflowStatus !== 'completed')
+      throw new Error(`generation checkpoint is incomplete: workflowStatus is ${JSON.stringify(checkpoint?.workflowStatus ?? null)}`);
+    const terminal = mode === 'red' ? 'step-05-validate-and-complete' : 'step-04-validate-and-summarize';
+    const required =
+      mode === 'red'
+        ? ['step-01-preflight-and-context', 'step-02-generation-mode', 'step-03-test-strategy', terminal]
+        : ['step-01-preflight-and-context', 'step-02-identify-targets', terminal];
+    const aggregation =
+      mode === 'red' ? ['step-04c-aggregate', 'step-04-generate-tests'] : ['step-03c-aggregate', 'step-03-generate-tests'];
+    const completed = Array.isArray(checkpoint.stepsCompleted) ? checkpoint.stepsCompleted : [];
+    const missing = required.filter((step) => !completed.includes(step));
+    if (!aggregation.some((step) => completed.includes(step))) missing.push(`one of ${aggregation.join(' or ')}`);
+    if (missing.length > 0 || checkpoint.lastStep !== terminal)
+      throw new Error(
+        `generation checkpoint does not retain completed mode-specific steps and terminal step: missing ${missing.join(', ') || 'none'}; lastStep ${JSON.stringify(checkpoint.lastStep ?? null)}; expected ${terminal}`,
+      );
+    if (result.generatedFiles.length === 0) throw new Error('generation completed without generated files');
+    if (checkpoint.test_mode !== mode || checkpoint.test_operation !== 'create')
+      throw new Error('generation checkpoint has inconsistent mode or operation');
+    for (const key of ['auto_validate', 'auto_heal_failures', 'max_healing_iterations', 'use_mcp_healing']) {
+      if (checkpoint[key] !== settings[key]) throw new Error(`generation checkpoint changed ${key}`);
+    }
+    if (checkpoint.healing_rounds_used !== result.healingRoundsUsed)
+      throw new Error('generation checkpoint and manifest disagree on repair rounds');
+    if (
+      (!settings.auto_validate || !settings.auto_heal_failures) &&
+      result.healingRoundsUsed !== (operation === 'resume' ? (checkpointBefore?.state.healing_rounds_used ?? 0) : 0)
+    )
+      throw new Error('disabled healing cannot consume repair rounds');
+    if (!settings.auto_validate && result.executionStatus !== 'disabled') throw new Error('disabled validation must report disabled');
+    if (settings.auto_validate && result.executionStatus === 'disabled')
+      throw new Error('validation was enabled but execution reports disabled');
+  }
+  const final = result.counts.final;
+  if (['passed', 'verified red'].includes(result.executionStatus)) {
+    if (final.executed === 0 || final.skipped !== 0 || result.executionReports.length === 0)
+      throw new Error('successful execution requires executed tests, reports, and no skipped results');
+    if (result.executionStatus === 'passed' && (mode !== 'expand' || final.failed !== 0))
+      throw new Error('passed requires expand mode with no failed tests');
+    if (
+      result.executionStatus === 'verified red' &&
+      (mode !== 'red' || final.passed !== 0 || final.intendedFailures !== final.failed || actual.assertionFailures !== final.failed)
+    )
+      throw new Error('verified red requires every executed test to fail for its intended criterion');
+  }
+  if (['failed', 'could not measure'].includes(result.executionStatus) && result.remainingFailures.length === 0)
+    throw new Error('failed or unmeasured execution requires a reported reason');
+  return result;
+}
+
+module.exports = { STATUSES, RESULT_KEYS, artifactPath, parseResult, reportCounts, frontmatter };

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

@@ -552,6 +552,8 @@ function resolveTeaConfig({ projectRoot, flags = {}, baseRef, skillRoot, skillNa
 module.exports = {
   resolveTeaConfig,
   readTeaConfigFile,
+  readWorkflowCustomization,
+  configSource,
   isPackageInstalled,
   KEY_TO_PACKAGE,
   KEY_TO_INSTALLED_FIELD,

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "bmad-method-test-architecture-enterprise",
-  "version": "2.0.3",
+  "version": "2.0.4-next.0",
   "description": "Master Test Architect for quality strategy, test automation, and release gates",
   "keywords": [
     "bmad",
@@ -33,6 +33,7 @@
   "bin": {
     "tea-atdd-red-check": "cli/atdd-red-check.js",
     "tea-atdd-runner": "cli/atdd-runner.js",
+    "tea-automate": "cli/automate.js",
     "tea-ci-runner": "cli/ci-runner.js",
     "tea-evaluate": "cli/evaluate.js",
     "tea-fragment-selection-runner": "cli/fragment-selection-runner.js",
@@ -89,12 +90,14 @@
     "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-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: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",
     "test:atdd-workflow-guidance": "node test/test-atdd-workflow-guidance.js",
+    "test:automate-cli": "node test/test-automate-cli.js",
     "test:automate-eval-fixture": "node test/test-automate-eval-fixture.js",
+    "test:automate-generation-evidence": "node test/test-automate-generation-evidence.js",
     "test:bmad-output-gated": "node test/test-bmad-output-gated.js",
     "test:boundary": "eval-quality-gates package-boundary",
     "test:changelog": "node test/test-stamp-changelog.js",
@@ -304,6 +307,7 @@
     "statements": 78
   },
   "dependencies": {
+    "@babel/parser": "^7.29.9",
     "@clack/prompts": "^0.11.0",
     "ajv": "^8.20.0",
     "boxen": "^5.1.2",

package/skills/bmad-testarch-automate/red/steps-c/step-04a-subagent-api-failing.md

@@ -32,6 +32,7 @@ This is an **isolated subagent** running in parallel with E2E red-phase test gen
 - 📖 Read this entire subagent file before acting
 - ✅ Generate red-phase API test scaffolds ONLY
 - ✅ Tests MUST be emitted with `test.skip()` until the developer activates them
+- ✅ Register each Playwright scaffold with a direct `test.skip` call and a literal criterion title. Literal `test.describe` suites may contain those calls. Avoid loops, `test.each()`, helper registrations, computed titles, and template titles; the CLI verifies each generated leaf against runner evidence.
 - ✅ Output structured JSON to temp file
 - ✅ Follow knowledge fragment patterns
 - ❌ Do NOT generate E2E tests (that's subagent 4B)

package/skills/bmad-testarch-automate/red/steps-c/step-04b-subagent-e2e-failing.md

@@ -29,6 +29,7 @@ This is an **isolated subagent** running in parallel with API red-phase test gen
 - 📖 Read this entire subagent file before acting
 - ✅ Generate red-phase E2E test scaffolds ONLY
 - ✅ Tests MUST be emitted with `test.skip()` until the developer activates them
+- ✅ Register each Playwright scaffold with a direct `test.skip` call and a literal criterion title. Literal `test.describe` suites may contain those calls. Avoid loops, `test.each()`, helper registrations, computed titles, and template titles; the CLI verifies each generated leaf against runner evidence.
 - ✅ Output structured JSON to temp file
 - ✅ Follow knowledge fragment patterns
 - ❌ Do NOT generate API tests (that's subagent 4A)

package/skills/bmad-testarch-automate/steps-c/step-03a-subagent-api.md

@@ -40,6 +40,7 @@ Gate broker calls on `pact_mcp_reachable`, not on `pact_mcp`. The mode says the
 
 - 📖 Read this entire subagent file before acting
 - ✅ Generate API tests ONLY
+- ✅ Register each Playwright test with a direct `test('literal title', ...)` call. Literal `test.describe('literal title', ...)` suites may contain those calls. Do not register tests through loops, `test.each()`, helper functions, computed titles, or template titles; the CLI cannot verify those dynamic registrations against runner evidence.
 - ✅ Output structured JSON to temp file
 - ✅ Follow knowledge fragment patterns
 - ❌ Do NOT generate E2E tests (that's subagent 3B)

package/skills/bmad-testarch-automate/steps-c/step-03b-subagent-e2e.md

@@ -28,6 +28,7 @@ This is an **isolated subagent** running in parallel with API test generation.
 
 - 📖 Read this entire subagent file before acting
 - ✅ Generate E2E tests ONLY
+- ✅ Register each Playwright test with a direct `test('literal title', ...)` call. Literal `test.describe('literal title', ...)` suites may contain those calls. Do not register tests through loops, `test.each()`, helper functions, computed titles, or template titles; the CLI cannot verify those dynamic registrations against runner evidence.
 - ✅ Output structured JSON to temp file
 - ✅ Follow knowledge fragment patterns
 - ❌ Do NOT generate API tests (that's subagent 3A)

package/skills/bmod-tea/bmod.toml

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