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

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 };