@poleski/quality-tools 0.1.4 → 0.2.1

package/dist/cli/main.js

@@ -1,5 +1,549 @@
 #!/usr/bin/env node
 
+// src/acceptance/command.ts
+import fs from "node:fs";
+import path from "node:path";
+import { glob } from "glob";
+
+// src/acceptance/dryChecker.ts
+var NEAR_DUPLICATE_THRESHOLD = 0.72;
+var POSSIBLE_SYNONYM_THRESHOLD = 0.45;
+var IGNORED_TOKENS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "and",
+  "are",
+  "be",
+  "i",
+  "in",
+  "is",
+  "of",
+  "the",
+  "then",
+  "to",
+  "when"
+]);
+function analyzeAcceptanceIrDryness(document, options = {}) {
+  const occurrences = document.scenarios.flatMap(
+    (scenario, scenarioIndex) => scenario.steps.map((step, stepIndex) => ({
+      step,
+      location: createLocation(scenario, scenarioIndex, step, stepIndex)
+    }))
+  );
+  const scenarioShapeGroups = findRepeatedScenarioShapes(document.scenarios);
+  const repeatedStepPatterns = findRepeatedStepPatterns(occurrences);
+  const findings = [
+    ...findDuplicateInScenario(document.scenarios),
+    ...options.includeExact ? findExactDuplicates(occurrences) : [],
+    ...findPlaceholderVariants(occurrences),
+    ...repeatedStepPatterns,
+    ...options.includeSimilar ? findSimilarSteps(occurrences) : []
+  ];
+  return {
+    schema_version: 1,
+    source_path: document.source_path,
+    feature_name: document.feature.name,
+    summary: {
+      scenarios: document.scenarios.length,
+      step_occurrences: occurrences.length,
+      unique_steps: new Set(occurrences.map((occurrence) => occurrence.step.text)).size,
+      repeated_step_patterns: repeatedStepPatterns.length,
+      repeated_scenario_shapes: scenarioShapeGroups.length,
+      findings: findings.length
+    },
+    repeated_scenario_shapes: scenarioShapeGroups,
+    findings
+  };
+}
+function findDuplicateInScenario(scenarios) {
+  return scenarios.flatMap((scenario, scenarioIndex) => {
+    const groups = groupOccurrences(scenario.steps.map((step, stepIndex) => ({
+      step,
+      location: createLocation(scenario, scenarioIndex, step, stepIndex)
+    })), (occurrence) => occurrence.step.text);
+    return [...groups.entries()].filter(([, members]) => containsDuplicateWithoutInterveningAction(scenario.steps, members)).map(([text, members]) => createFinding({
+      kind: "duplicate-in-scenario",
+      confidence: "high",
+      canonicalCandidate: text,
+      members,
+      reason: "the same step text appears more than once in one scenario",
+      suggestedAction: "Review the scenario and remove the repeated step if it is accidental."
+    }));
+  });
+}
+function containsDuplicateWithoutInterveningAction(steps, members) {
+  const stepIndexes = members.map((member) => member.location.step_index).sort((left, right) => left - right);
+  return stepIndexes.some((stepIndex, index) => {
+    const nextStepIndex = stepIndexes[index + 1];
+    return nextStepIndex !== void 0 && !hasInterveningAction(steps, stepIndex, nextStepIndex);
+  });
+}
+function hasInterveningAction(steps, leftIndex, rightIndex) {
+  const effectiveKeywords = getEffectiveKeywords(steps);
+  return steps.slice(leftIndex + 1, rightIndex).some((_, offset) => {
+    const effectiveKeyword = effectiveKeywords[leftIndex + offset + 1];
+    return effectiveKeyword === "Given" || effectiveKeyword === "When";
+  });
+}
+function getEffectiveKeywords(steps) {
+  let currentKeyword = "Given";
+  return steps.map((step) => {
+    if (step.keyword !== "And" && step.keyword !== "But") {
+      currentKeyword = step.keyword;
+    }
+    return currentKeyword;
+  });
+}
+function findExactDuplicates(occurrences) {
+  return [...groupOccurrences(occurrences, (occurrence) => occurrence.step.text).entries()].filter(([, members]) => members.length > 1).map(([text, members]) => createFinding({
+    kind: "exact-duplicate",
+    confidence: "medium",
+    canonicalCandidate: text,
+    members,
+    reason: "the same step text appears more than once in the feature",
+    suggestedAction: "Keep repeated setup vocabulary when intentional; normalize only accidental drift."
+  }));
+}
+function findPlaceholderVariants(occurrences) {
+  return [...groupOccurrences(occurrences, (occurrence) => normalizePlaceholders(occurrence.step.text)).entries()].filter(([, members]) => members.length > 1 && new Set(members.map((member) => member.step.text)).size > 1).map(([text, members]) => createFinding({
+    kind: "placeholder-variant",
+    confidence: "high",
+    canonicalCandidate: text,
+    patternCandidate: patternFromPlaceholderText(text),
+    members,
+    reason: "step text is identical after replacing placeholder names with generic slots",
+    suggestedAction: "Normalize the Gherkin if the different placeholder names do not add reader meaning."
+  }));
+}
+function findRepeatedStepPatterns(occurrences) {
+  return [...groupOccurrences(occurrences, (occurrence) => normalizeStepPattern(occurrence.step.text)).entries()].filter(([, members]) => members.length > 1 && new Set(members.map((member) => member.step.text)).size > 1).map(([pattern, members]) => createFinding({
+    kind: "repeated-step-pattern",
+    confidence: "high",
+    canonicalCandidate: pattern,
+    patternCandidate: pattern,
+    members,
+    reason: "step text follows the same generalized pattern with different example values",
+    suggestedAction: "Consider a Scenario Outline, data table, or shared Background if the repeated shape is intentional."
+  }));
+}
+function findSimilarSteps(occurrences) {
+  return findSimilarStepCandidates(occurrences).map(createSimilarStepFinding);
+}
+function findSimilarStepCandidates(occurrences) {
+  return occurrences.flatMap(
+    (left, leftIndex) => occurrences.slice(leftIndex + 1).map((right) => createSimilarStepCandidate(left, right)).filter((candidate) => candidate !== void 0)
+  );
+}
+function createSimilarStepCandidate(left, right) {
+  if (!shouldCompareSimilarSteps(left, right)) {
+    return void 0;
+  }
+  const score = tokenSimilarity(left.step.text, right.step.text);
+  return score >= POSSIBLE_SYNONYM_THRESHOLD ? { left, right, score } : void 0;
+}
+function shouldCompareSimilarSteps(left, right) {
+  return left.step.text !== right.step.text && normalizePlaceholders(left.step.text) !== normalizePlaceholders(right.step.text);
+}
+function createSimilarStepFinding(candidate) {
+  return createFinding({
+    kind: similarStepKind(candidate.score),
+    confidence: similarStepConfidence(candidate.score),
+    canonicalCandidate: candidate.left.step.text,
+    members: [candidate.left, candidate.right],
+    reason: "step texts share similar normalized tokens",
+    score: Number(candidate.score.toFixed(3)),
+    suggestedAction: "Review whether these steps express the same behavior before changing feature wording."
+  });
+}
+function similarStepKind(score) {
+  return score >= NEAR_DUPLICATE_THRESHOLD ? "near-duplicate" : "possible-synonym";
+}
+function similarStepConfidence(score) {
+  return score >= NEAR_DUPLICATE_THRESHOLD ? "medium" : "low";
+}
+function createLocation(scenario, scenarioIndex, step, stepIndex) {
+  return {
+    section: "scenario",
+    scenario_index: scenarioIndex,
+    scenario_name: scenario.name,
+    step_index: stepIndex,
+    keyword: step.keyword,
+    line: step.line
+  };
+}
+function findRepeatedScenarioShapes(scenarios) {
+  const exactShapeGroups = [...groupOccurrences(
+    scenarios.map((scenario, scenarioIndex) => ({ scenario, scenarioIndex })),
+    ({ scenario }) => scenario.steps.map((step) => normalizeStepPattern(step.text)).join("\n")
+  ).entries()].filter(([, members]) => members.length > 1).map(([, members]) => createScenarioShapeGroup(members, members[0]?.scenario.steps.length ?? 0, "high"));
+  const prefixShapeGroups = [...groupOccurrences(
+    scenarios.map((scenario, scenarioIndex) => ({
+      scenario,
+      scenarioIndex,
+      prefix: longestSetupPrefix(scenario)
+    })).filter((entry) => entry.prefix.length >= 3),
+    ({ prefix }) => prefix.join("\n")
+  ).entries()].filter(([, members]) => members.length > 1).map(([, members]) => createScenarioShapeGroup(members, members[0]?.prefix.length ?? 0, "medium"));
+  return dedupeScenarioShapeGroups([...exactShapeGroups, ...prefixShapeGroups]);
+}
+function createScenarioShapeGroup(members, sharedStepCount, confidence) {
+  const pattern = members[0]?.prefix ?? members[0]?.scenario.steps.slice(0, sharedStepCount).map((step) => normalizeStepPattern(step.text)) ?? [];
+  return {
+    confidence,
+    scenario_count: members.length,
+    shared_step_count: sharedStepCount,
+    pattern,
+    scenarios: members.map(({ scenario, scenarioIndex }) => ({
+      scenario_index: scenarioIndex,
+      scenario_name: scenario.name,
+      line: scenario.line,
+      examples: scenario.examples.length
+    })),
+    reason: confidence === "high" ? "multiple scenarios have the same generalized step sequence" : "multiple scenarios share the same setup or action prefix before diverging into specific assertions",
+    suggested_action: confidence === "high" ? "Consider collapsing these scenarios into a Scenario Outline or a data-driven runner." : "Consider moving the shared prefix into Background or a host fixture if it does not need to be repeated in every scenario."
+  };
+}
+function longestSetupPrefix(scenario) {
+  const normalizedSteps = scenario.steps.map((step) => normalizeStepPattern(step.text));
+  const assertionIndex = scenario.steps.findIndex((step) => step.keyword === "Then");
+  const prefixLength = assertionIndex === -1 ? normalizedSteps.length : assertionIndex;
+  return normalizedSteps.slice(0, prefixLength);
+}
+function dedupeScenarioShapeGroups(groups) {
+  const seen = /* @__PURE__ */ new Set();
+  const sorted = groups.sort(
+    (left, right) => right.scenario_count - left.scenario_count || right.shared_step_count - left.shared_step_count || left.confidence.localeCompare(right.confidence)
+  );
+  return sorted.filter((group) => {
+    const scenarioKey = group.scenarios.map((scenario) => scenario.scenario_index).join(",");
+    const key = `${scenarioKey}:${group.shared_step_count}:${group.pattern.join("\n")}`;
+    if (seen.has(key)) {
+      return false;
+    }
+    seen.add(key);
+    return true;
+  });
+}
+function createFinding(input) {
+  return {
+    kind: input.kind,
+    confidence: input.confidence,
+    canonical_candidate: input.canonicalCandidate,
+    ...input.patternCandidate ? { pattern_candidate: input.patternCandidate } : {},
+    ...input.score === void 0 ? {} : { score: input.score },
+    members: [...groupOccurrences(input.members, (member) => member.step.text).entries()].map(([text, members]) => ({
+      text,
+      locations: members.map((member) => member.location)
+    })),
+    reason: input.reason,
+    suggested_action: input.suggestedAction
+  };
+}
+function groupOccurrences(values, keySelector) {
+  const groups = /* @__PURE__ */ new Map();
+  values.forEach((value) => {
+    const key = keySelector(value);
+    groups.set(key, [...groups.get(key) ?? [], value]);
+  });
+  return groups;
+}
+function normalizePlaceholders(text) {
+  let index = 0;
+  return text.replace(/<[^>]+>/g, () => {
+    index += 1;
+    return `<_${index}>`;
+  });
+}
+function normalizeStepPattern(text) {
+  return normalizePlaceholders(text).replace(/\b\d+\b/g, "<number>").replace(/\bexamples\/[A-Za-z0-9_-]+\b/g, "<workspace>").replace(/\b[A-Za-z0-9._/-]+\.[A-Za-z0-9]+\b/g, "<path>").replace(/\b(File|Folder|Package|Symbol|Namespace|Function|Callable|Method|Constructor|Prototype|Class|Interface|Record|Delegate|Property|Event|Type|Struct|Union|Enum|Alias|Template|Typedef|Variable|Constant|Global|Field|Parameter|Local|Godot class_name)\b/g, "<node-type>").replace(/\b(Include|Imports|References|Calls|Type imports|Inherits|Using|Call|Implements|Loads|Nests|Contains|Overrides|TypeScript Alias Import)\b/g, "<edge-type>").replace(/\s+/g, " ").trim();
+}
+function patternFromPlaceholderText(text) {
+  const escaped = text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return `^${escaped.replace(/<_[0-9]+>/g, "(.+)")}$`;
+}
+function tokenSimilarity(left, right) {
+  const leftTokens = tokenize(left);
+  const rightTokens = tokenize(right);
+  const union = /* @__PURE__ */ new Set([...leftTokens, ...rightTokens]);
+  if (union.size === 0) {
+    return 0;
+  }
+  const intersection = [...leftTokens].filter((token) => rightTokens.has(token));
+  return intersection.length / union.size;
+}
+function tokenize(text) {
+  return new Set(
+    text.replace(/<[^>]+>/g, " ").toLowerCase().split(/[^a-z0-9]+/u).filter((token) => token.length > 0 && !IGNORED_TOKENS.has(token))
+  );
+}
+
+// src/acceptance/ir.ts
+function toAcceptanceIr(document) {
+  return {
+    schema_version: 1,
+    source_path: document.sourcePath,
+    feature: {
+      name: document.feature.name,
+      line: document.feature.line
+    },
+    ...document.background ? {
+      background: {
+        line: document.background.line,
+        steps: document.background.steps.map(toAcceptanceIrStep)
+      }
+    } : {},
+    scenarios: document.scenarios.map((scenario) => ({
+      name: scenario.name,
+      line: scenario.line,
+      steps: scenario.steps.map(toAcceptanceIrStep),
+      examples: scenario.examples.map((example) => ({
+        line: example.line,
+        values: example.values
+      }))
+    }))
+  };
+}
+function toAcceptanceIrStep(documentStep) {
+  return {
+    keyword: documentStep.keyword,
+    text: documentStep.text,
+    line: documentStep.line,
+    parameters: documentStep.parameters
+  };
+}
+
+// src/acceptance/parser.ts
+var FEATURE_PATTERN = /^#{0,6}\s*Feature:\s*(.+)$/;
+var BACKGROUND_PATTERN = /^#{0,6}\s*Background:\s*$/;
+var SCENARIO_PATTERN = /^#{0,6}\s*Scenario:\s*(.+)$/;
+var SCENARIO_OUTLINE_PATTERN = /^#{0,6}\s*Scenario Outline:\s*(.+)$/;
+var EXAMPLES_PATTERN = /^#{0,6}\s*Examples:\s*$/;
+var STEP_PATTERN = /^(Given|When|Then|And|But)\s+(.+)$/;
+var PARAMETER_PATTERN = /<([A-Za-z0-9_]+)>/g;
+var LINE_PARSERS = [
+  parseFeatureHeading,
+  parseBackgroundHeading,
+  parseScenarioHeading,
+  parseExamplesHeading,
+  parseExamplesRowLine,
+  parseStepLine
+];
+function parseAcceptanceFeature(featureSource, sourcePath) {
+  const state = createParserState(sourcePath);
+  parseFeatureLines(state, featureSource);
+  validateDocument(state);
+  return createDocument(state);
+}
+function createParserState(sourcePath) {
+  return {
+    sourcePath,
+    scenarios: [],
+    scenariosWithExamples: /* @__PURE__ */ new Set()
+  };
+}
+function parseFeatureLines(state, featureSource) {
+  featureSource.split(/\r?\n/).forEach((rawLine, index) => {
+    const lineNumber = index + 1;
+    const line = rawLine.trim();
+    parseFeatureLine(state, line, lineNumber);
+  });
+}
+function parseFeatureLine(state, line, lineNumber) {
+  if (line === "") {
+    return;
+  }
+  for (const parseLine of LINE_PARSERS) {
+    if (parseLine(state, line, lineNumber)) {
+      return;
+    }
+  }
+}
+function parseFeatureHeading(state, line, lineNumber) {
+  const featureMatch = FEATURE_PATTERN.exec(line);
+  if (!featureMatch) {
+    return false;
+  }
+  state.feature = {
+    name: featureMatch[1].trim(),
+    line: lineNumber
+  };
+  clearActiveTargets(state);
+  return true;
+}
+function parseBackgroundHeading(state, line, lineNumber) {
+  if (!BACKGROUND_PATTERN.test(line)) {
+    return false;
+  }
+  if (state.background) {
+    throw new Error(`${state.sourcePath}:${lineNumber} Feature has more than one Background`);
+  }
+  state.background = {
+    line: lineNumber,
+    steps: []
+  };
+  state.stepTarget = state.background;
+  clearExamplesTarget(state);
+  return true;
+}
+function parseScenarioHeading(state, line, lineNumber) {
+  const scenarioMatch = SCENARIO_PATTERN.exec(line) ?? SCENARIO_OUTLINE_PATTERN.exec(line);
+  if (!scenarioMatch) {
+    return false;
+  }
+  const scenario = {
+    name: scenarioMatch[1].trim(),
+    line: lineNumber,
+    steps: [],
+    examples: []
+  };
+  state.scenarios.push(scenario);
+  state.stepTarget = scenario;
+  clearExamplesTarget(state);
+  return true;
+}
+function parseExamplesHeading(state, line, lineNumber) {
+  if (!EXAMPLES_PATTERN.test(line)) {
+    return false;
+  }
+  const scenario = state.scenarios.at(-1);
+  if (!scenario) {
+    throw new Error(`${state.sourcePath}:${lineNumber} Examples appear before a Scenario`);
+  }
+  state.examplesTarget = scenario;
+  state.scenariosWithExamples.add(scenario);
+  state.stepTarget = void 0;
+  state.examplesHeaders = void 0;
+  return true;
+}
+function parseExamplesRowLine(state, line, lineNumber) {
+  if (!line.startsWith("|")) {
+    return false;
+  }
+  if (!state.examplesTarget) {
+    return true;
+  }
+  const values = parseExamplesRow(line);
+  if (!state.examplesHeaders) {
+    setExamplesHeaders(state, values, lineNumber);
+    return true;
+  }
+  if (values.length !== state.examplesHeaders.length) {
+    throw new Error(`${state.sourcePath}:${lineNumber} Examples row has ${values.length} cells; expected ${state.examplesHeaders.length}`);
+  }
+  state.examplesTarget.examples.push({
+    line: lineNumber,
+    values: Object.fromEntries(state.examplesHeaders.map((header, cellIndex) => [header, values[cellIndex] ?? ""]))
+  });
+  return true;
+}
+function setExamplesHeaders(state, values, lineNumber) {
+  state.examplesHeaders = values;
+  if (state.examplesHeaders.length === 0) {
+    throw new Error(`${state.sourcePath}:${lineNumber} Examples header must contain at least one column`);
+  }
+}
+function parseStepLine(state, line, lineNumber) {
+  const stepMatch = STEP_PATTERN.exec(line);
+  if (!stepMatch) {
+    return false;
+  }
+  if (!state.stepTarget) {
+    throw new Error(`${state.sourcePath}:${lineNumber} Step appears before a Scenario or Background`);
+  }
+  const text = stepMatch[2].trim();
+  state.stepTarget.steps.push({
+    keyword: stepMatch[1],
+    text,
+    line: lineNumber,
+    parameters: extractParameters(text)
+  });
+  return true;
+}
+function clearActiveTargets(state) {
+  state.stepTarget = void 0;
+  clearExamplesTarget(state);
+}
+function clearExamplesTarget(state) {
+  state.examplesTarget = void 0;
+  state.examplesHeaders = void 0;
+}
+function validateDocument(state) {
+  assertFeatureExists(state);
+  assertHasScenarios(state);
+  assertBackgroundHasSteps(state);
+  assertScenariosHaveSteps(state);
+  assertExamplesHaveRows(state);
+}
+function assertFeatureExists(state) {
+  if (!state.feature) {
+    throw new Error(`${state.sourcePath}: Expected a Feature heading`);
+  }
+}
+function assertHasScenarios(state) {
+  if (state.scenarios.length === 0) {
+    throw new Error(`${state.sourcePath}: Expected at least one Scenario`);
+  }
+}
+function assertBackgroundHasSteps(state) {
+  if (state.background && state.background.steps.length === 0) {
+    throw new Error(`${state.sourcePath}:${state.background.line} Background must contain at least one step`);
+  }
+}
+function assertScenariosHaveSteps(state) {
+  const emptyScenario = state.scenarios.find((scenario) => scenario.steps.length === 0);
+  if (emptyScenario) {
+    throw new Error(`${state.sourcePath}:${emptyScenario.line} Scenario "${emptyScenario.name}" must contain at least one step`);
+  }
+}
+function assertExamplesHaveRows(state) {
+  const emptyExamples = state.scenarios.find(
+    (scenario) => state.scenariosWithExamples.has(scenario) && scenario.examples.length === 0
+  );
+  if (emptyExamples) {
+    throw new Error(`${state.sourcePath}:${emptyExamples.line} Scenario "${emptyExamples.name}" has Examples without rows`);
+  }
+}
+function createDocument(state) {
+  return {
+    sourcePath: state.sourcePath,
+    feature: state.feature,
+    ...state.background ? { background: state.background } : {},
+    scenarios: state.scenarios
+  };
+}
+function extractParameters(text) {
+  return [...text.matchAll(PARAMETER_PATTERN)].map((match) => match[1] ?? "");
+}
+function parseExamplesRow(line) {
+  return line.slice(1, line.endsWith("|") ? -1 : void 0).split("|").map((cell) => cell.trim());
+}
+
+// src/acceptance/playwright/generator.ts
+import { readFileSync } from "node:fs";
+var runtimeTemplateUrl = new URL("./templates/playwright-acceptance-runtime.ts.template", import.meta.url);
+function generatePlaywrightAcceptanceSpec(options) {
+  return [
+    "/* Generated by quality-tools acceptance generate. Do not edit. */",
+    "import { test } from '@playwright/test';",
+    `import { acceptanceSteps, createAcceptanceContext } from ${quote(options.stepsImportPath)};`,
+    `import { loadAcceptanceIr, runAcceptanceFeature } from ${quote(options.runtimeImportPath)};`,
+    "",
+    `const feature = loadAcceptanceIr(${quote(options.irImportPath)});`,
+    "",
+    "runAcceptanceFeature(test, feature, {",
+    "  acceptanceSteps,",
+    "  createAcceptanceContext",
+    "});",
+    ""
+  ].join("\n");
+}
+function generatePlaywrightAcceptanceRuntime() {
+  return readFileSync(runtimeTemplateUrl, "utf8");
+}
+function quote(value) {
+  return `'${value.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/\r/g, "\\r").replace(/\n/g, "\\n")}'`;
+}
+
 // src/shared/flagValue.ts
 function flagValue(args2, name) {
   const inlineFlag = args2.find((arg) => arg.startsWith(`${name}=`));
@@ -31,6 +575,229 @@ function cleanCliArgs(args2) {
   return args2.filter((arg) => arg !== "--");
 }
 
+// src/acceptance/command.ts
+var ACCEPTANCE_COMMANDS = /* @__PURE__ */ new Map([
+  ["parse", parseCommand],
+  ["dry-check", dryCheckCommand],
+  ["generate", generateCommand],
+  ["compile", compileCommand]
+]);
+var COMPILE_VALUE_FLAGS = [
+  "--steps",
+  "--ir",
+  "--dry",
+  "--spec",
+  "--out-dir",
+  "--ir-dir",
+  "--dry-report-dir"
+];
+async function runAcceptanceCli(rawArgs, options = {}) {
+  const args2 = cleanCliArgs(rawArgs);
+  const [command2, ...commandArgs] = args2;
+  const cwd = options.cwd ?? process.cwd();
+  if (isHelpCommand(command2)) {
+    console.log(acceptanceUsage());
+    return;
+  }
+  await requireAcceptanceCommand(command2)(commandArgs, cwd);
+}
+function acceptanceUsage() {
+  return [
+    "Usage:",
+    "  quality-tools acceptance parse <feature-file> <json-output>",
+    "  quality-tools acceptance dry-check [--include-exact] [--include-similar] <json-ir> <report-output>",
+    "  quality-tools acceptance generate <json-ir> <generated-test-output> --steps <path>",
+    "  quality-tools acceptance compile <spec-glob> <generated-output-dir> --steps <path> [--ir <dir>] [--dry <dir>]"
+  ].join("\n");
+}
+function parseCommand(args2, cwd) {
+  const [featurePath, jsonOutputPath, ...extraArgs] = args2;
+  if (!featurePath || !jsonOutputPath || extraArgs.length > 0) {
+    throw new Error("Usage: quality-tools acceptance parse <feature-file> <json-output>");
+  }
+  const ir = parseIrFile(cwd, featurePath);
+  writeJsonFile(path.resolve(cwd, jsonOutputPath), ir);
+}
+function dryCheckCommand(args2, cwd) {
+  const options = parseDryCheckOptions(args2);
+  const report = analyzeAcceptanceIrDryness(readIrFile(cwd, options.irPath), {
+    includeExact: options.includeExact,
+    includeSimilar: options.includeSimilar
+  });
+  writeJsonFile(path.resolve(cwd, options.reportPath), report);
+}
+function generateCommand(args2, cwd) {
+  const options = parseGenerateOptions(args2);
+  writeGeneratedPlaywrightSpec(cwd, options.irPath, options.outPath, options.stepsPath);
+}
+async function compileCommand(args2, cwd) {
+  const options = parseCompileOptions(args2);
+  const specFiles = await findSpecFiles(cwd, options.specPatterns);
+  if (specFiles.length === 0) {
+    throw new Error(`No acceptance specs matched: ${options.specPatterns.join(", ")}`);
+  }
+  const generatedDir = path.resolve(cwd, options.generatedDir);
+  writePlaywrightRuntime(generatedDir);
+  specFiles.forEach((specFile) => {
+    const ir = parseIrFile(cwd, specFile);
+    const slug = sourcePathSlug(ir.source_path);
+    const irPath = path.join(path.resolve(cwd, options.irDir), `${slug}.json`);
+    const generatedPath = path.join(generatedDir, `${slug}.spec.ts`);
+    writeJsonFile(irPath, ir);
+    if (options.dryDir) {
+      writeJsonFile(path.join(path.resolve(cwd, options.dryDir), `${slug}.json`), analyzeAcceptanceIrDryness(ir, {
+        includeExact: options.includeExact,
+        includeSimilar: options.includeSimilar
+      }));
+    }
+    writeGeneratedPlaywrightSpec(cwd, irPath, generatedPath, options.stepsPath);
+  });
+}
+function parseDryCheckOptions(args2) {
+  const positional = args2.filter((arg) => !arg.startsWith("--"));
+  if (positional.length !== 2) {
+    throw new Error("Usage: quality-tools acceptance dry-check [--include-exact] [--include-similar] <json-ir> <report-output>");
+  }
+  return {
+    irPath: positional[0] ?? "",
+    reportPath: positional[1] ?? "",
+    includeExact: args2.includes("--include-exact"),
+    includeSimilar: args2.includes("--include-similar")
+  };
+}
+function parseGenerateOptions(args2) {
+  const positional = args2.filter((arg, index) => arg !== "--steps" && args2[index - 1] !== "--steps" && !arg.startsWith("--"));
+  if (positional.length !== 2) {
+    throw new Error("Usage: quality-tools acceptance generate <json-ir> <generated-test-output> --steps <path>");
+  }
+  return {
+    irPath: positional[0] ?? "",
+    outPath: positional[1] ?? "",
+    stepsPath: requireFlagValue(args2, "--steps")
+  };
+}
+function parseCompileOptions(args2) {
+  const positional = collectPositionalArgs(args2, COMPILE_VALUE_FLAGS);
+  const specPatterns = resolveCompileSpecPatterns(args2, positional);
+  const generatedDir = requireCompileGeneratedDir(specPatterns, resolveGeneratedDir(args2, positional));
+  return {
+    specPatterns,
+    stepsPath: requireFlagValue(args2, "--steps"),
+    generatedDir,
+    irDir: resolveIrDir(args2, generatedDir),
+    dryDir: resolveDryDir(args2),
+    includeExact: args2.includes("--include-exact"),
+    includeSimilar: args2.includes("--include-similar")
+  };
+}
+function isHelpCommand(command2) {
+  return !command2 || command2 === "--help" || command2 === "-h";
+}
+function requireAcceptanceCommand(command2) {
+  const runner = command2 ? ACCEPTANCE_COMMANDS.get(command2) : void 0;
+  if (!runner) {
+    throw new Error(acceptanceUsage());
+  }
+  return runner;
+}
+function collectPositionalArgs(args2, valueFlags) {
+  return args2.filter(
+    (arg, index) => !arg.startsWith("--") && !isFlagValue(args2, index, valueFlags)
+  );
+}
+function resolveCompileSpecPatterns(args2, positional) {
+  const specFlags = collectFlagValues(args2, "--spec");
+  return specFlags.length > 0 ? specFlags : positional.slice(0, 1);
+}
+function resolveGeneratedDir(args2, positional) {
+  return collectFlagValues(args2, "--out-dir").at(0) ?? positional[1];
+}
+function requireCompileGeneratedDir(specPatterns, generatedDir) {
+  if (specPatterns.length === 0 || !generatedDir) {
+    throw new Error("Usage: quality-tools acceptance compile <spec-glob> <generated-output-dir> --steps <path> [--ir <dir>] [--dry <dir>]");
+  }
+  return generatedDir;
+}
+function resolveIrDir(args2, generatedDir) {
+  return collectFlagValues(args2, "--ir").at(0) ?? collectFlagValues(args2, "--ir-dir").at(0) ?? path.join(generatedDir, "..", "generated-ir");
+}
+function resolveDryDir(args2) {
+  return collectFlagValues(args2, "--dry").at(0) ?? collectFlagValues(args2, "--dry-report-dir").at(0);
+}
+function parseIrFile(cwd, featurePath) {
+  const resolvedPath = path.resolve(cwd, featurePath);
+  const source = fs.readFileSync(resolvedPath, "utf8");
+  return toAcceptanceIr(parseAcceptanceFeature(source, toPosixPath(path.relative(cwd, resolvedPath))));
+}
+function readIrFile(cwd, irPath) {
+  return JSON.parse(fs.readFileSync(path.resolve(cwd, irPath), "utf8"));
+}
+function writeGeneratedPlaywrightSpec(cwd, irPath, outPath, stepsPath) {
+  const resolvedOutPath = path.resolve(cwd, outPath);
+  const generatedDir = path.dirname(resolvedOutPath);
+  writePlaywrightRuntime(generatedDir);
+  writeFile(resolvedOutPath, generatePlaywrightAcceptanceSpec({
+    irImportPath: toPosixPath(path.relative(cwd, path.resolve(cwd, irPath))),
+    runtimeImportPath: createExtensionlessImportPath(resolvedOutPath, path.join(generatedDir, "runtime.ts")),
+    stepsImportPath: createExtensionlessImportPath(resolvedOutPath, path.resolve(cwd, stepsPath))
+  }));
+}
+function writePlaywrightRuntime(generatedDir) {
+  writeFile(path.join(generatedDir, "runtime.ts"), generatePlaywrightAcceptanceRuntime());
+}
+function writeJsonFile(filePath, data) {
+  writeFile(filePath, `${JSON.stringify(data, null, 2)}
+`);
+}
+function writeFile(filePath, content) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, content);
+}
+async function findSpecFiles(cwd, patterns) {
+  const files = await Promise.all(
+    patterns.map((pattern) => glob(pattern, { absolute: true, cwd, nodir: true }))
+  );
+  return [...new Set(files.flat())].sort((left, right) => left.localeCompare(right));
+}
+function createExtensionlessImportPath(outPath, targetPath) {
+  const relativePath = toPosixPath(path.relative(path.dirname(outPath), targetPath));
+  const extension = path.extname(relativePath);
+  const extensionlessPath = extension ? relativePath.slice(0, -extension.length) : relativePath;
+  if (extensionlessPath.startsWith(".")) {
+    return extensionlessPath;
+  }
+  return `./${extensionlessPath}`;
+}
+function collectFlagValues(args2, flag) {
+  const values = [];
+  args2.forEach((arg, index) => {
+    if (arg === flag) {
+      const value = args2[index + 1];
+      if (!value || value.startsWith("--")) {
+        throw new Error(`Missing value for ${flag}`);
+      }
+      values.push(value);
+    }
+  });
+  return values;
+}
+function requireFlagValue(args2, flag) {
+  const value = collectFlagValues(args2, flag).at(0);
+  if (!value) {
+    throw new Error(`Missing required ${flag} <path>`);
+  }
+  return value;
+}
+function isFlagValue(args2, index, flags) {
+  return flags.includes(args2[index - 1] ?? "");
+}
+function toPosixPath(value) {
+  return value.split(path.sep).join(path.posix.sep);
+}
+function sourcePathSlug(sourcePath) {
+  return sourcePath.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+
 // src/shared/resolve/repoRoot.ts
 import { resolve as resolve3 } from "node:path";
 
@@ -138,12 +905,12 @@ import { existsSync as existsSync4, statSync } from "fs";
 import { isAbsolute, resolve as resolve4 } from "path";
 
 // src/shared/util/workspacePackages.ts
-import { existsSync as existsSync3, readFileSync } from "fs";
+import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
 import { basename, dirname as dirname4, join as join3 } from "path";
 import { globSync } from "glob";
 function workspacePackageFromPackageJson(repoRoot, relativePackageJson) {
   const packageJsonPath = join3(repoRoot, relativePackageJson);
-  const manifest = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+  const manifest = JSON.parse(readFileSync2(packageJsonPath, "utf-8"));
   const relativeRoot = toPosix(dirname4(relativePackageJson));
   return {
     ...manifest.name ? { manifestName: manifest.name } : {},
@@ -157,7 +924,7 @@ function pnpmWorkspaceGlobs(repoRoot) {
   if (!existsSync3(workspacePath)) {
     return [];
   }
-  const lines = readFileSync(workspacePath, "utf-8").split(/\r?\n/);
+  const lines = readFileSync2(workspacePath, "utf-8").split(/\r?\n/);
   const packageGlobs = [];
   let inPackagesBlock = false;
   for (const line of lines) {
@@ -183,7 +950,7 @@ function packageJsonWorkspaceGlobs(repoRoot) {
   if (!existsSync3(packageJsonPath)) {
     return [];
   }
-  const manifest = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+  const manifest = JSON.parse(readFileSync2(packageJsonPath, "utf-8"));
   if (Array.isArray(manifest.workspaces)) {
     return manifest.workspaces;
   }
@@ -216,7 +983,7 @@ function listWorkspacePackages(repoRoot) {
   const packages = [];
   const packageJsons = discoverWorkspacePackageJsons(repoRoot);
   if (shouldIncludeRootPackage(repoRoot, packageJsons)) {
-    const packageJson = JSON.parse(readFileSync(join3(repoRoot, "package.json"), "utf-8"));
+    const packageJson = JSON.parse(readFileSync2(join3(repoRoot, "package.json"), "utf-8"));
     packages.push({
       ...packageJson.name ? { manifestName: packageJson.name } : {},
       name: packageJson.name?.split("/").pop() ?? "root",
@@ -334,7 +1101,7 @@ import { basename as basename3, join as join8 } from "path";
 import { basename as basename2 } from "path";
 
 // src/organize/cohesion/imports/parse.ts
-import { readFileSync as readFileSync2 } from "fs";
+import { readFileSync as readFileSync3 } from "fs";
 import * as ts2 from "typescript";
 
 // src/organize/cohesion/imports/scriptKind.ts
@@ -375,7 +1142,7 @@ function extractImports(sourceFile) {
 }
 function parseFileImports(filePath, fileName) {
   try {
-    const fileContent = readFileSync2(filePath, "utf-8");
+    const fileContent = readFileSync3(filePath, "utf-8");
     const scriptKind = getScriptKind(fileName);
     const sourceFile = ts2.createSourceFile(
       fileName,
@@ -412,7 +1179,7 @@ function resolveImportTarget(fromFile, specifier, candidatePaths) {
 }
 
 // src/config/quality.ts
-import { readFileSync as readFileSync3 } from "fs";
+import { readFileSync as readFileSync4 } from "fs";
 import { isAbsolute as isAbsolute2, join as join6, matchesGlob, relative as relative2, resolve as resolve5 } from "path";
 
 // src/config/patterns.ts
@@ -450,7 +1217,7 @@ var DEFAULT_REPORTS_DIR = "reports/quality-tools";
 function loadQualityConfig(repoRoot) {
   const configPath = join6(repoRoot, CONFIG_FILE);
   try {
-    return JSON.parse(readFileSync3(configPath, "utf-8"));
+    return JSON.parse(readFileSync4(configPath, "utf-8"));
   } catch {
     return {};
   }
@@ -872,7 +1639,7 @@ function runBoundariesCli(rawArgs, dependencies = DEFAULT_DEPENDENCIES) {
 
 // src/crap/analysis/run.ts
 import { existsSync as existsSync6 } from "fs";
-import * as path2 from "path";
+import * as path3 from "path";
 
 // src/crap/analysis/calculate.ts
 function calculateCrap(complexity, coverage) {
@@ -997,8 +1764,8 @@ function extractFunctions(sourceFile) {
 }
 
 // src/crap/analysis/fileSelection.ts
-import { readFileSync as readFileSync4 } from "fs";
-import * as path from "path";
+import { readFileSync as readFileSync5 } from "fs";
+import * as path2 from "path";
 import * as ts7 from "typescript";
 function matchesFilterScope(relativePath, filterScope) {
   if (!filterScope) {
@@ -1010,7 +1777,7 @@ function matchesFilterScope(relativePath, filterScope) {
   return relativePath.startsWith(`${filterScope}/`);
 }
 function shouldIncludeFile(filePath, filterScope, repoRoot) {
-  const relativePath = toPosix(path.relative(repoRoot, filePath));
+  const relativePath = toPosix(path2.relative(repoRoot, filePath));
   if (!matchesFilterScope(relativePath, filterScope)) {
     return false;
   }
@@ -1022,13 +1789,13 @@ function shouldIncludeFile(filePath, filterScope, repoRoot) {
     repoRoot,
     workspacePackage.name,
     "crap",
-    toPosix(path.relative(workspacePackage.root, filePath))
+    toPosix(path2.relative(workspacePackage.root, filePath))
   );
 }
 function createSourceFile3(filePath) {
   return ts7.createSourceFile(
     filePath,
-    readFileSync4(filePath, "utf-8"),
+    readFileSync5(filePath, "utf-8"),
     ts7.ScriptTarget.Latest,
     true,
     filePath.endsWith(".tsx") ? ts7.ScriptKind.TSX : ts7.ScriptKind.TS
@@ -1058,7 +1825,7 @@ function analyzeCoverageEntry(filePath, fileCoverage, repoRoot, threshold) {
       complexity: fn.complexity,
       coverage: Math.round(coverage),
       crap: Math.round(crap * 100) / 100,
-      file: toPosix(path2.relative(repoRoot, fn.file)),
+      file: toPosix(path3.relative(repoRoot, fn.file)),
       line: fn.line,
       name: fn.name
     };
@@ -1180,12 +1947,12 @@ function createCoverageProfiles(repoRoot, target) {
 }
 
 // src/crap/coverage/read.ts
-import { existsSync as existsSync7, readFileSync as readFileSync5 } from "fs";
-function readCoverageReport(path3) {
-  if (!existsSync7(path3)) {
-    throw new Error(`Coverage data not found: ${path3}`);
+import { existsSync as existsSync7, readFileSync as readFileSync6 } from "fs";
+function readCoverageReport(path4) {
+  if (!existsSync7(path4)) {
+    throw new Error(`Coverage data not found: ${path4}`);
   }
-  return JSON.parse(readFileSync5(path3, "utf-8"));
+  return JSON.parse(readFileSync6(path4, "utf-8"));
 }
 
 // src/crap/report.ts
@@ -1366,9 +2133,9 @@ function copySharedMutationReports(reportKey, repoRoot = process.cwd()) {
 }
 
 // src/mutation/reporting/check.ts
-import { readFileSync as readFileSync6 } from "fs";
+import { readFileSync as readFileSync7 } from "fs";
 function findMutationSiteViolations(reportPath, threshold = 50) {
-  const report = JSON.parse(readFileSync6(reportPath, "utf-8"));
+  const report = JSON.parse(readFileSync7(reportPath, "utf-8"));
   return Object.entries(report.files ?? {}).map(([file, entry]) => ({ count: (entry.mutants ?? []).length, file })).filter((entry) => entry.count > threshold).sort((left, right) => right.count - left.count);
 }
 function reportMutationSiteViolations(reportPath, threshold = 50) {
@@ -1665,7 +2432,7 @@ function parseBareMutationTargetArg(args2) {
   }
   return void 0;
 }
-function collectFlagValues(args2, name) {
+function collectFlagValues2(args2, name) {
   const values = [];
   for (let index = 0; index < args2.length; index += 1) {
     const arg = args2[index];
@@ -1692,11 +2459,11 @@ function parseJsonStringArray(value, flagName) {
 }
 function mutationRunOptions(args2) {
   const mutateGlobs = [
-    ...collectFlagValues(args2, "--mutate-glob"),
+    ...collectFlagValues2(args2, "--mutate-glob"),
     ...parseJsonStringArray(flagValue(args2, "--mutate-globs-json"), "--mutate-globs-json")
   ];
   const testIncludes = [
-    ...collectFlagValues(args2, "--test-include"),
+    ...collectFlagValues2(args2, "--test-include"),
     ...parseJsonStringArray(flagValue(args2, "--test-includes-json"), "--test-includes-json")
   ];
   return {
@@ -1726,7 +2493,7 @@ import { join as join16 } from "path";
 import { relative as relative7 } from "path";
 
 // src/organize/rules.ts
-import { readFileSync as readFileSync7 } from "fs";
+import { readFileSync as readFileSync8 } from "fs";
 import { join as join14 } from "path";
 var DEFAULT_CONFIG2 = {
   lowInfoNames: {
@@ -1753,7 +2520,7 @@ function mergeConfig(defaults, overrides) {
 function loadOrganizeConfig(repoRoot, packageName) {
   const configPath = join14(repoRoot, CONFIG_FILE3);
   try {
-    const rawConfig = JSON.parse(readFileSync7(configPath, "utf-8"));
+    const rawConfig = JSON.parse(readFileSync8(configPath, "utf-8"));
     const defaultConfig = rawConfig.defaults?.organize;
     const packageConfig = packageName ? rawConfig.packages?.[packageName]?.organize : void 0;
     const mergedDefaults = defaultConfig ? mergeConfig(DEFAULT_CONFIG2, defaultConfig) : DEFAULT_CONFIG2;
@@ -1938,7 +2705,7 @@ function shouldStartNewToken(previous, current, next) {
 }
 
 // src/organize/naming/tokenize.ts
-function tokenize(name) {
+function tokenize2(name) {
   const withoutExtension = stripExtension(name);
   const characters = Array.from(withoutExtension);
   const tokens = [];
@@ -1969,7 +2736,7 @@ function tokenize(name) {
 function buildPrefixGroups(fileNames) {
   const groups = /* @__PURE__ */ new Map();
   for (const fileName of fileNames) {
-    const tokens = tokenize(fileName);
+    const tokens = tokenize2(fileName);
     if (tokens.length > 0) {
       const prefix = tokens[0];
       if (!groups.has(prefix)) {
@@ -1983,7 +2750,7 @@ function buildPrefixGroups(fileNames) {
 function countFirstTokens(fileNames) {
   const tokenCounts = /* @__PURE__ */ new Map();
   for (const fileName of fileNames) {
-    const tokens = tokenize(fileName);
+    const tokens = tokenize2(fileName);
     if (tokens.length > 0) {
       const token = tokens[0];
       tokenCounts.set(token, (tokenCounts.get(token) ?? 0) + 1);
@@ -2187,9 +2954,9 @@ function isConventionalEntryFile(filePath, ancestorFolders) {
     return false;
   }
   const hookName = fileStem.slice(3);
-  const hookTokens = tokenize(hookName);
+  const hookTokens = tokenize2(hookName);
   return hookTokens.some((hookToken) => ancestorFolders.some((folder) => {
-    const folderTokens = tokenize(folder);
+    const folderTokens = tokenize2(folder);
     return folderTokens.includes(hookToken);
   }));
 }
@@ -2200,13 +2967,13 @@ function pathRedundancy(filePath, ancestorFolders) {
     return 0;
   }
   const fileName = basename5(filePath);
-  const fileTokens = tokenize(fileName);
+  const fileTokens = tokenize2(fileName);
   if (fileTokens.length === 0) {
     return 0;
   }
   const ancestorTokens = /* @__PURE__ */ new Set();
   for (const folder of ancestorFolders) {
-    const folderTokens = tokenize(folder);
+    const folderTokens = tokenize2(folder);
     for (const token of folderTokens) {
       ancestorTokens.add(token);
     }
@@ -2232,7 +2999,7 @@ function computeAverageRedundancy(fileNames, ancestorFolders) {
 }
 
 // src/organize/analyze/issues.ts
-import { readFileSync as readFileSync8 } from "fs";
+import { readFileSync as readFileSync9 } from "fs";
 
 // src/organize/metric/naming/details.ts
 var LOW_INFO_NAME_DETAILS = {
@@ -2374,7 +3141,7 @@ function collectFileIssues(fileNames, directoryPath, ancestorFolders, lowInfoNam
     }
     try {
       const filePath = `${directoryPath}/${fileName}`;
-      const fileContent = readFileSync8(filePath, "utf-8");
+      const fileContent = readFileSync9(filePath, "utf-8");
       const barrelIssue = checkBarrelFile(fileName, fileContent);
       if (barrelIssue) {
         issues.push(barrelIssue);
@@ -2427,7 +3194,7 @@ function analyze(target) {
 }
 
 // src/organize/compare/baseline.ts
-import { readFileSync as readFileSync9 } from "fs";
+import { readFileSync as readFileSync10 } from "fs";
 
 // src/organize/compare/verdict.ts
 function verdictFromDeltas(fileFanOutDelta, folderFanOutDelta, clusterCountDelta, issueCountDelta, redundancyDelta) {
@@ -2463,7 +3230,7 @@ function baselineMetricsByPath(baseline2) {
   return new Map(baseline2.map((metric) => [metric.directoryPath, metric]));
 }
 function compareBaseline(current, baselinePath) {
-  const baselineData = JSON.parse(readFileSync9(baselinePath, "utf-8"));
+  const baselineData = JSON.parse(readFileSync10(baselinePath, "utf-8"));
   const previousByPath = baselineMetricsByPath(baselineData);
   const comparisons = /* @__PURE__ */ new Map();
   for (const metric of current) {
@@ -2754,11 +3521,11 @@ function runReachabilityCli(rawArgs, dependencies = DEFAULT_DEPENDENCIES4) {
 }
 
 // src/scrap/analysis/pipeline/run.ts
-import * as fs from "fs";
+import * as fs2 from "fs";
 import * as ts25 from "typescript";
 
 // src/scrap/test/discovery/files.ts
-import { readFileSync as readFileSync10 } from "fs";
+import { readFileSync as readFileSync11 } from "fs";
 
 // src/scrap/test/discovery/globs.ts
 import { globSync as globSync2 } from "glob";
@@ -2866,7 +3633,7 @@ function discoverTestFiles(target) {
   return packageNamesForTarget(target, REPO_ROOT).flatMap((packageName) => discoverPackageTestFiles(packageName, REPO_ROOT)).filter((filePath) => isInsideTarget(target, REPO_ROOT, filePath));
 }
 function readBaselineMetrics(baselinePath) {
-  return JSON.parse(readFileSync10(baselinePath, "utf-8"));
+  return JSON.parse(readFileSync11(baselinePath, "utf-8"));
 }
 function baselineMetricsByPath2(baseline2) {
   return new Map(
@@ -4100,8 +4867,8 @@ function compareBlockSummaries(left, right) {
 
 // src/scrap/structure/blocks/groups.ts
 var BLOCK_SEPARATOR = "";
-function blockPathKey(path3) {
-  return path3.join(BLOCK_SEPARATOR);
+function blockPathKey(path4) {
+  return path4.join(BLOCK_SEPARATOR);
 }
 function blockPathFromKey(key) {
   return key.split(BLOCK_SEPARATOR);
@@ -4127,7 +4894,7 @@ function averageScore2(examples) {
 function countExamples2(examples, predicate) {
   return examples.filter(predicate).length;
 }
-function summarizeBlock(path3, examples) {
+function summarizeBlock(path4, examples) {
   const meanScore = averageScore2(examples);
   const maxScore2 = examples.reduce((max, example) => Math.max(max, example.score), 0);
   const hotExampleCount2 = countExamples2(examples, (example) => example.score >= 8);
@@ -4142,8 +4909,8 @@ function summarizeBlock(path3, examples) {
     hotExampleCount: hotExampleCount2,
     lowAssertionExampleCount: countExamples2(examples, (example) => example.assertionCount <= 1),
     maxScore: maxScore2,
-    name: path3[path3.length - 1],
-    path: path3,
+    name: path4[path4.length - 1],
+    path: path4,
     remediationMode: remediationMode(examples.length, meanScore, hotExampleCount2, maxScore2),
     zeroAssertionExampleCount: countExamples2(examples, (example) => example.assertionCount === 0)
   };
@@ -4521,7 +5288,7 @@ function analyzeScrapFile(sourceFile) {
 // src/scrap/analysis/pipeline/run.ts
 function analyzeScrap(target) {
   return discoverTestFiles(target).map((filePath) => {
-    const source = fs.readFileSync(filePath, "utf-8");
+    const source = fs2.readFileSync(filePath, "utf-8");
     const sourceFile = ts25.createSourceFile(
       filePath,
       source,
@@ -4677,8 +5444,8 @@ function resolveScrapPolicy(args2) {
 }
 
 // src/scrap/report/blocks/format.ts
-function formatBlockPath(path3) {
-  return path3.join(" > ");
+function formatBlockPath(path4) {
+  return path4.join(" > ");
 }
 function interestingBlocks(metric) {
   return metric.blockSummaries.filter((block) => block.remediationMode !== "STABLE").slice(0, 5);
@@ -4896,6 +5663,7 @@ function runScrapCli(rawArgs, dependencies = DEFAULT_DEPENDENCIES5) {
 
 // src/cli/main.ts
 var COMMANDS = {
+  acceptance: runAcceptanceCli,
   boundaries: runBoundariesCli,
   crap: runCrapCli,
   init: runInitCli,
@@ -4909,6 +5677,7 @@ function printHelp() {
 
 Commands:
   init          Create a starter quality.config.json
+  acceptance    Compile human-authored acceptance specs into executable tests
   organize     Check folder structure, naming, and cohesion
   boundaries   Check package/layer boundaries
   reachability Check dead surfaces and dead ends