@lumenflow/cli 3.12.4 → 3.12.6

package/dist/chunk-NMG736UR.js

@@ -0,0 +1,683 @@
+import {
+  DIRECTORIES
+} from "./chunk-DWMLTXKQ.js";
+
+// ../core/dist/work-classifier.js
+import { minimatch } from "minimatch";
+var WORK_DOMAINS = {
+  UI: "ui",
+  BACKEND: "backend",
+  DOCS: "docs",
+  INFRA: "infra",
+  MIXED: "mixed"
+};
+var TEST_METHODOLOGY_HINTS = {
+  SMOKE_TEST: "smoke-test",
+  STRUCTURED_CONTENT: "structured-content"
+};
+var SIGNAL_WEIGHTS = {
+  CODE_PATHS: 1,
+  LANE: 0.6,
+  TYPE: 0.3,
+  DESCRIPTION: 0.2
+};
+var CONFIDENCE_THRESHOLD = 0.3;
+var SMOKE_TEST_THRESHOLD = 0.5;
+var STRUCTURED_CONTENT_CODE_PATH_PATTERNS = Object.freeze([
+  "**/*.yaml",
+  "**/*.yml",
+  "**/*.json",
+  "**/*.md",
+  "**/*.mdx"
+]);
+var DEFAULT_UI_CODE_PATH_PATTERNS = Object.freeze([
+  // Stylesheets
+  "**/*.css",
+  "**/*.scss",
+  "**/*.less",
+  "**/*.module.css",
+  "**/*.module.scss",
+  // Styled components
+  "**/*.styled.ts",
+  "**/*.styled.tsx",
+  "**/*.styled.js",
+  "**/*.styled.jsx",
+  // Component / page directories
+  "**/components/**",
+  "**/pages/**",
+  // Next.js / app router conventions
+  "**/app/**/page.tsx",
+  "**/app/**/page.ts",
+  "**/app/**/page.jsx",
+  "**/app/**/page.js",
+  "**/app/**/layout.tsx",
+  "**/app/**/layout.ts",
+  "**/app/**/layout.jsx",
+  "**/app/**/layout.js",
+  "**/app/page.tsx",
+  "**/app/page.ts",
+  "**/app/layout.tsx",
+  "**/app/layout.ts"
+]);
+var DEFAULT_UI_LANE_HINTS = Object.freeze([
+  "Experience",
+  "Frontend",
+  "UI",
+  "Design"
+]);
+var DEFAULT_DOCS_CODE_PATH_PATTERNS = Object.freeze([
+  "docs/**",
+  "**/*.md",
+  "**/*.mdx",
+  "README*",
+  "CHANGELOG*"
+]);
+var DEFAULT_DOCS_LANE_HINTS = Object.freeze([
+  "Content",
+  "Documentation",
+  "Docs"
+]);
+var DEFAULT_INFRA_CODE_PATH_PATTERNS = Object.freeze([
+  ".github/**",
+  "Dockerfile*",
+  "docker-compose*",
+  "**/terraform/**",
+  "**/k8s/**",
+  "**/kubernetes/**",
+  "infrastructure/**"
+]);
+var DEFAULT_INFRA_LANE_HINTS = Object.freeze([
+  "Operations",
+  "Infrastructure",
+  "DevOps",
+  "Platform"
+]);
+var UI_DESCRIPTION_KEYWORDS = Object.freeze([
+  "css",
+  "scss",
+  "less",
+  "stylesheet",
+  "component",
+  "layout",
+  "responsive",
+  "ui",
+  "frontend",
+  "styled",
+  "animation",
+  "theme"
+]);
+var DOCS_DESCRIPTION_KEYWORDS = Object.freeze([
+  "documentation",
+  "readme",
+  "changelog",
+  "docs",
+  "guide",
+  "tutorial"
+]);
+var INFRA_DESCRIPTION_KEYWORDS = Object.freeze([
+  "docker",
+  "kubernetes",
+  "terraform",
+  "ci/cd",
+  "pipeline",
+  "deploy",
+  "infrastructure"
+]);
+function createDomainSignals(domain) {
+  return { domain, maxWeight: 0, signals: [] };
+}
+function addSignal(ds, signal) {
+  ds.signals.push(signal);
+  if (signal.weight > ds.maxWeight) {
+    ds.maxWeight = signal.weight;
+  }
+}
+function matchCodePaths(codePaths, patterns) {
+  for (const path of codePaths) {
+    for (const pattern of patterns) {
+      if (minimatch(path, pattern)) {
+        return pattern;
+      }
+    }
+  }
+  return void 0;
+}
+function isStructuredContentOnly(codePaths) {
+  return codePaths.length > 0 && codePaths.every((path) => STRUCTURED_CONTENT_CODE_PATH_PATTERNS.some((pattern) => minimatch(path, pattern, { nocase: true })));
+}
+function matchLaneHint(lane, hints) {
+  const parts = lane.split(":");
+  const laneParent = (parts[0] ?? "").trim().toLowerCase();
+  const laneSublane = parts.length > 1 ? (parts[1] ?? "").trim().toLowerCase() : "";
+  for (const hint of hints) {
+    const hintLower = hint.toLowerCase();
+    if (laneParent === hintLower || laneSublane === hintLower) {
+      return hint;
+    }
+  }
+  return void 0;
+}
+function matchDescriptionKeywords(description, keywords) {
+  const descLower = description.toLowerCase();
+  for (const keyword of keywords) {
+    if (descLower.includes(keyword.toLowerCase())) {
+      return keyword;
+    }
+  }
+  return void 0;
+}
+var DOMAIN_CAPABILITIES = {
+  [WORK_DOMAINS.UI]: ["ui-design-awareness", "component-reuse-check"],
+  [WORK_DOMAINS.DOCS]: ["documentation-structure", "link-validation"],
+  [WORK_DOMAINS.INFRA]: ["infrastructure-review", "security-check"],
+  [WORK_DOMAINS.MIXED]: ["cross-domain-awareness"],
+  [WORK_DOMAINS.BACKEND]: []
+};
+function getCapabilities(domain) {
+  return DOMAIN_CAPABILITIES[domain] ?? [];
+}
+function classifyWork(doc, config) {
+  const codePaths = doc.code_paths ?? [];
+  const lane = doc.lane ?? "";
+  const type = doc.type ?? "";
+  const description = doc.description ?? "";
+  const structuredContentOnly = isStructuredContentOnly(codePaths);
+  const uiCodePathPatterns = [
+    ...DEFAULT_UI_CODE_PATH_PATTERNS,
+    ...config?.ui?.code_path_patterns ?? []
+  ];
+  const uiLaneHints = [...DEFAULT_UI_LANE_HINTS, ...config?.ui?.lane_hints ?? []];
+  const ui = createDomainSignals(WORK_DOMAINS.UI);
+  const docs = createDomainSignals(WORK_DOMAINS.DOCS);
+  const infra = createDomainSignals(WORK_DOMAINS.INFRA);
+  if (codePaths.length > 0) {
+    const uiMatch = matchCodePaths(codePaths, uiCodePathPatterns);
+    if (uiMatch) {
+      addSignal(ui, {
+        source: "code_paths",
+        domain: WORK_DOMAINS.UI,
+        weight: SIGNAL_WEIGHTS.CODE_PATHS,
+        match: uiMatch
+      });
+    }
+    const docsMatch = matchCodePaths(codePaths, DEFAULT_DOCS_CODE_PATH_PATTERNS);
+    if (docsMatch) {
+      addSignal(docs, {
+        source: "code_paths",
+        domain: WORK_DOMAINS.DOCS,
+        weight: SIGNAL_WEIGHTS.CODE_PATHS,
+        match: docsMatch
+      });
+    }
+    const infraMatch = matchCodePaths(codePaths, DEFAULT_INFRA_CODE_PATH_PATTERNS);
+    if (infraMatch) {
+      addSignal(infra, {
+        source: "code_paths",
+        domain: WORK_DOMAINS.INFRA,
+        weight: SIGNAL_WEIGHTS.CODE_PATHS,
+        match: infraMatch
+      });
+    }
+  }
+  if (lane) {
+    const uiLaneMatch = matchLaneHint(lane, uiLaneHints);
+    if (uiLaneMatch) {
+      addSignal(ui, {
+        source: "lane",
+        domain: WORK_DOMAINS.UI,
+        weight: SIGNAL_WEIGHTS.LANE,
+        match: uiLaneMatch
+      });
+    }
+    const docsLaneMatch = matchLaneHint(lane, DEFAULT_DOCS_LANE_HINTS);
+    if (docsLaneMatch) {
+      addSignal(docs, {
+        source: "lane",
+        domain: WORK_DOMAINS.DOCS,
+        weight: SIGNAL_WEIGHTS.LANE,
+        match: docsLaneMatch
+      });
+    }
+    const infraLaneMatch = matchLaneHint(lane, DEFAULT_INFRA_LANE_HINTS);
+    if (infraLaneMatch) {
+      addSignal(infra, {
+        source: "lane",
+        domain: WORK_DOMAINS.INFRA,
+        weight: SIGNAL_WEIGHTS.LANE,
+        match: infraLaneMatch
+      });
+    }
+  }
+  if (type === "documentation") {
+    addSignal(docs, {
+      source: "type",
+      domain: WORK_DOMAINS.DOCS,
+      weight: SIGNAL_WEIGHTS.TYPE,
+      match: "documentation"
+    });
+  }
+  if (description) {
+    const uiKeywordMatch = matchDescriptionKeywords(description, UI_DESCRIPTION_KEYWORDS);
+    if (uiKeywordMatch) {
+      addSignal(ui, {
+        source: "description",
+        domain: WORK_DOMAINS.UI,
+        weight: SIGNAL_WEIGHTS.DESCRIPTION,
+        match: uiKeywordMatch
+      });
+    }
+    const docsKeywordMatch = matchDescriptionKeywords(description, DOCS_DESCRIPTION_KEYWORDS);
+    if (docsKeywordMatch) {
+      addSignal(docs, {
+        source: "description",
+        domain: WORK_DOMAINS.DOCS,
+        weight: SIGNAL_WEIGHTS.DESCRIPTION,
+        match: docsKeywordMatch
+      });
+    }
+    const infraKeywordMatch = matchDescriptionKeywords(description, INFRA_DESCRIPTION_KEYWORDS);
+    if (infraKeywordMatch) {
+      addSignal(infra, {
+        source: "description",
+        domain: WORK_DOMAINS.INFRA,
+        weight: SIGNAL_WEIGHTS.DESCRIPTION,
+        match: infraKeywordMatch
+      });
+    }
+  }
+  const candidates = [ui, docs, infra].filter((d) => d.maxWeight >= CONFIDENCE_THRESHOLD);
+  const strongCodePathDomains = [ui, docs, infra].filter((d) => d.signals.some((s) => s.source === "code_paths"));
+  if (strongCodePathDomains.length > 1) {
+    const allSignals = strongCodePathDomains.flatMap((d) => d.signals);
+    return {
+      domain: WORK_DOMAINS.MIXED,
+      confidence: Math.max(...strongCodePathDomains.map((d) => d.maxWeight)),
+      signals: allSignals,
+      capabilities: getCapabilities(WORK_DOMAINS.MIXED),
+      testMethodologyHint: void 0
+    };
+  }
+  if (candidates.length === 0) {
+    return {
+      domain: WORK_DOMAINS.BACKEND,
+      confidence: 0,
+      signals: [],
+      capabilities: [],
+      testMethodologyHint: structuredContentOnly ? TEST_METHODOLOGY_HINTS.STRUCTURED_CONTENT : void 0
+    };
+  }
+  candidates.sort((a, b) => b.maxWeight - a.maxWeight);
+  const winner = candidates[0];
+  const testMethodologyHint = winner.domain === WORK_DOMAINS.UI && winner.maxWeight >= SMOKE_TEST_THRESHOLD ? TEST_METHODOLOGY_HINTS.SMOKE_TEST : structuredContentOnly ? TEST_METHODOLOGY_HINTS.STRUCTURED_CONTENT : void 0;
+  return {
+    domain: winner.domain,
+    confidence: winner.maxWeight,
+    signals: winner.signals,
+    capabilities: getCapabilities(winner.domain),
+    testMethodologyHint
+  };
+}
+
+// ../core/dist/spawn-guidance-generators.js
+var DEFAULT_WORKTREES_DIR_SEGMENT = DIRECTORIES.WORKTREES.replace(/\/+$/g, "");
+var EXISTING_TESTS_TYPES = ["refactor"];
+var SMOKE_TEST_TYPES = ["visual", "design", "ui"];
+var DOCS_ONLY_TYPES = ["documentation", "docs", "config"];
+function generateTDDDirective() {
+  return `## \u26D4 TDD DIRECTIVE \u2014 READ BEFORE CODING
+
+**IF YOU WRITE IMPLEMENTATION CODE BEFORE A FAILING TEST, YOU HAVE FAILED THIS WU.**
+
+### Test-First Workflow (MANDATORY)
+
+1. Write a failing test for the acceptance criteria
+2. Run the test to confirm it fails (RED)
+3. Implement the minimum code to pass the test
+4. Run the test to confirm it passes (GREEN)
+5. Refactor if needed, keeping tests green
+
+### Test Ratchet Rule (WU-1253)
+
+Gates compare test results against \`.lumenflow/test-baseline.json\`:
+
+- **NEW failures** (not in baseline) **BLOCK** gates - you must fix them
+- **Pre-existing failures** (in baseline) show **WARNING** - do not block your WU
+- When tests are **fixed**, baseline auto-updates (ratchet forward)
+
+If gates fail due to test failures:
+1. Check if failure is in baseline: \`cat .lumenflow/test-baseline.json\`
+2. If pre-existing: continue, it will warn but not block
+3. If NEW: fix the test or add to baseline with reason and fix-wu
+
+### Why This Matters
+
+- Tests document expected behavior BEFORE implementation
+- Prevents scope creep and over-engineering
+- Ensures every feature has verification
+- Failing tests prove the test actually tests something
+- Ratchet pattern prevents being blocked by unrelated failures`;
+}
+function generateDocsGuidance() {
+  return `## Documentation Standards
+
+**Format check only** - No TDD required for documentation WUs.
+
+### Requirements
+
+1. Run \`pnpm gates --docs-only\` before completion
+2. Ensure markdown formatting is correct
+3. Verify links are valid
+4. Check spelling and grammar`;
+}
+function generateSmokeTestGuidance() {
+  return `## UI/Visual Verification Strategy
+
+**Prefer user-outcome verification over brittle DOM assertions** for UI-classified work.
+
+### Recommended Order
+
+1. Cover critical user flows with integration or E2E tests when behavior crosses component boundaries
+2. Add smoke/render coverage for crash-prone states, loading states, and empty states
+3. Use unit tests for pure logic only (formatters, reducers, validators, accessibility helpers, slug builders)
+4. Verify responsive behavior and accessibility manually or with automation
+5. Avoid tests that only snapshot CSS classes or markup shape unless that contract is intentional`;
+}
+function generateRefactorGuidance() {
+  return `## Refactor Testing
+
+**Existing tests must pass** - Refactoring must not break current behavior.
+
+### Requirements
+
+1. Run all existing tests BEFORE refactoring
+2. Run all existing tests AFTER refactoring
+3. No new tests required unless behavior changes
+4. If tests fail after refactor, the refactor introduced a bug`;
+}
+function usesNonTddSummaryHint(options) {
+  return options?.testMethodologyHint === TEST_METHODOLOGY_HINTS.SMOKE_TEST || options?.testMethodologyHint === TEST_METHODOLOGY_HINTS.STRUCTURED_CONTENT;
+}
+function generateStructuredContentGuidance() {
+  return `## Structured Content Testing
+
+**Content/config validation over TDD** - Structured content changes should be verified with parsing, linting, and domain evaluation.
+
+### Requirements
+
+1. Validate file parseability and schema compatibility (where schema exists)
+2. Run relevant lint/format checks for content/config files
+3. Run project/domain evaluators for prompt or policy content when available
+4. Execute at least one manual/automated smoke check for changed content path
+5. Document evidence/results in completion notes`;
+}
+function generateCodeCraftGuidance() {
+  return `## Code Craft
+
+Use these implementation standards while you write code:
+
+1. **Extract repeated literals to named constants**. Use your project's duplicate-string threshold (configured in \`eslint.config.mjs\`) and extract meaningful numbers.
+\`\`\`ts
+// Before
+if (status === 'in_progress') notify('in_progress');
+if (nextStatus === 'in_progress') log('in_progress');
+if (prevStatus === 'in_progress') audit('in_progress');
+
+// After
+const STATUS_IN_PROGRESS = 'in_progress';
+if (status === STATUS_IN_PROGRESS) notify(STATUS_IN_PROGRESS);
+\`\`\`
+
+2. **Write error messages with context**: what failed, why, and next action.
+\`\`\`ts
+// Before
+die('failed');
+
+// After
+die('Failed to parse workspace.yaml: missing lane field. Run pnpm lane:setup to regenerate.');
+\`\`\`
+
+3. **Prefer existing libraries for common problems** (parsing, validation, dates, schema, paths) before custom implementations.
+\`\`\`ts
+// Before
+function parseDate(input: string) { /* custom parser */ }
+
+// After
+import { parseISO } from 'date-fns';
+const parsed = parseISO(input);
+\`\`\`
+
+4. **Use type narrowing instead of unsafe casts**.
+\`\`\`ts
+// Before
+const id = (payload as { id: string }).id;
+
+// After
+if (payload && typeof payload === 'object' && 'id' in payload) {
+  const id = String(payload.id);
+}
+\`\`\`
+
+5. **Extract duplicated logic when it appears at your project's extraction threshold**.
+\`\`\`ts
+// Before: same branch checks repeated in multiple files
+if (mode === 'branch-pr') { /* ... */ }
+
+// After
+function isBranchPrMode(mode: string): boolean {
+  return mode === 'branch-pr';
+}
+\`\`\`
+
+6. **Keep functions focused**. One function should do one clear job.
+\`\`\`ts
+// Before
+function completeWuAndNotifyAndWriteAudit() { /* many responsibilities */ }
+
+// After
+function completeWu() { /* completion only */ }
+function notifyCompletion() { /* notification only */ }
+\`\`\`
+
+7. **Inject infrastructure dependencies into application logic** instead of importing them directly.
+\`\`\`ts
+// Before
+import { readFileSync } from 'node:fs';
+function loadSpec(path: string) { return readFileSync(path, 'utf8'); }
+
+// After
+function loadSpec(path: string, readText: (p: string) => string) {
+  return readText(path);
+}
+\`\`\``;
+}
+function generateReadBeforeWriteDiscipline() {
+  return `## Read Before Write
+
+Understand the change before touching code:
+
+1. Read each file you plan to edit from top to bottom.
+2. Read adjacent files that define related types, helpers, and boundaries.
+3. Find callers and dependents (for example with \`rg\`) before changing behavior.
+4. Confirm acceptance criteria and code_paths still match your intended scope.
+5. Never edit a file you have not read first.
+6. If you cannot determine impact from reading alone, ask before proceeding.`;
+}
+function generateSelfReviewDirective(id) {
+  return `## Self-Review Before Completion
+
+Before you finish ${id}, review your own diff against gate and craft checks:
+
+1. [GATE] Repeated strings at your project threshold are extracted to named constants.
+2. [STANDARD] Semantic numbers use named constants (except simple loop indexes and 0/1 guards).
+3. [STANDARD] Error messages explain what failed, why, and how to fix.
+4. [STANDARD] No \`as\` casts without preceding type narrowing or guards.
+5. [GATE] No \`TODO\` or \`FIXME\` markers in production changes.
+6. [GATE] Architecture boundaries are respected (no forbidden cross-layer imports).
+
+Fix any failed checks before running completion commands.`;
+}
+function generateMandatoryStandards(policy, options) {
+  const lines = ["## Mandatory Standards", ""];
+  lines.push("- **LumenFlow**: Follow trunk-based flow, WIP=1, worktree discipline");
+  if (options?.testMethodologyHint === TEST_METHODOLOGY_HINTS.SMOKE_TEST) {
+    lines.push("- **Verification Strategy**: Prefer user-outcome verification over brittle DOM assertions. Use integration/E2E, smoke coverage, and manual or visual checks as appropriate.");
+  } else if (options?.testMethodologyHint === TEST_METHODOLOGY_HINTS.STRUCTURED_CONTENT) {
+    lines.push("- **Verification Strategy**: Verify structured content with fixtures, schema checks, or targeted integration coverage. Do not force runtime TDD for content-only changes.");
+  } else if (policy.testing === "tdd") {
+    lines.push(`- **TDD**: Failing test first, then implementation, then passing test. ${policy.coverage_threshold}%+ coverage on new application code`);
+  } else if (policy.testing === "test-after") {
+    lines.push(`- **Test-After**: Write implementation first, then add tests. ${policy.coverage_threshold}%+ coverage on new application code`);
+  } else if (policy.testing === "none") {
+    lines.push("- **Testing**: Tests are optional for this project");
+  }
+  if (policy.architecture === "hexagonal") {
+    lines.push("- **Hexagonal Architecture**: Ports-first design. No application -> infrastructure imports");
+  } else if (policy.architecture === "layered") {
+    lines.push("- **Layered Architecture**: Clear layer separation. Each layer can only depend on layers below it");
+  }
+  lines.push("- **Code Craft**: See Code Craft section below for constants, DRY, SRP, DI, error handling, and type safety rules with examples");
+  lines.push("- **KISS/YAGNI**: Solve the stated problem with the minimum code. Do not add features, parameters, abstractions, or configurability beyond what acceptance criteria require");
+  lines.push("- **Worktree Discipline**: ALWAYS use `pnpm wu:claim` to create worktrees (never `git worktree add` directly). Work ONLY in the worktree, never edit main");
+  lines.push("- **Documentation**: Update tooling docs if changing tools. Keep docs in sync with code");
+  lines.push("- **Sub-agents**: Use Explore agent for codebase investigation. Activate mandatory agents as configured for your project");
+  return lines.join("\n");
+}
+function generatePolicyBasedTestGuidance(wuType, policy, options) {
+  const type = (wuType || "feature").toLowerCase();
+  if (DOCS_ONLY_TYPES.includes(type)) {
+    return generateDocsGuidance();
+  }
+  if (SMOKE_TEST_TYPES.includes(type)) {
+    return generateSmokeTestGuidance();
+  }
+  if (options?.testMethodologyHint === TEST_METHODOLOGY_HINTS.STRUCTURED_CONTENT) {
+    return generateStructuredContentGuidance();
+  }
+  if (options?.testMethodologyHint === TEST_METHODOLOGY_HINTS.SMOKE_TEST) {
+    return generateSmokeTestGuidance();
+  }
+  if (EXISTING_TESTS_TYPES.includes(type)) {
+    return generateRefactorGuidance();
+  }
+  switch (policy.testing) {
+    case "test-after":
+      return generateTestAfterDirective(policy.coverage_threshold);
+    case "none":
+      return generateTestingOptionalDirective();
+    case "tdd":
+    default:
+      return generateTDDDirective();
+  }
+}
+function generateTestAfterDirective(coverageThreshold) {
+  return `## Test-After Methodology
+
+**Write implementation first, then add tests** - Focus on solving the problem, then verify.
+
+### Test-After Workflow
+
+1. Understand the acceptance criteria
+2. Write implementation first
+3. Add tests to verify behavior
+4. Aim for ${coverageThreshold}% coverage on new code
+
+### When This Works
+
+- Exploratory prototyping where requirements are unclear
+- Quick iterations where test-first slows discovery
+- Projects configured with \`methodology.testing: 'test-after'\`
+
+### Requirements
+
+- Tests must be added before \`wu:done\`
+- Coverage target: ${coverageThreshold}%+ on new application code
+- All existing tests must still pass`;
+}
+function generateTestingOptionalDirective() {
+  return `## Testing Optional
+
+**Tests are not required** - Project is configured without test requirements.
+
+### Focus
+
+- Code quality and functionality
+- Run \`pnpm gates\` before completion (will skip coverage checks)
+
+### If You Want to Add Tests
+
+You can still add tests for critical functionality:
+\`\`\`bash
+pnpm test -- --coverage
+\`\`\`
+
+But they are not required for WU completion.`;
+}
+function generateDesignContextSection(classification) {
+  if (classification.domain !== "ui") {
+    return "";
+  }
+  return `## Design Context
+
+This work involves UI components or styling. Follow these guidelines:
+
+### Pattern Check
+
+- Before creating new components, check for existing patterns in the codebase
+- Search for similar components that may already solve the problem
+- Verify design system tokens and variables are used instead of hardcoded values
+
+### Viewport Verification
+
+- Test across common viewport sizes (mobile: 375px, tablet: 768px, desktop: 1280px)
+- Verify responsive behavior at breakpoints
+- Check for overflow, text truncation, and layout shifts
+
+### Accessibility
+
+- Verify keyboard navigation works for interactive elements
+- Ensure sufficient color contrast (WCAG 2.1 AA minimum)
+- Add appropriate ARIA attributes where needed
+- Test with screen reader if applicable
+
+### Codebase Exploration
+
+- Check the project's design system or component library before building custom
+- Look for CSS variables, theme tokens, or shared style utilities
+- Review existing component patterns for consistency`;
+}
+function generateEnforcementSummary(policy, options) {
+  const lines = ["## You will be judged by", ""];
+  if (options?.testMethodologyHint === TEST_METHODOLOGY_HINTS.SMOKE_TEST) {
+    lines.push("- **Testing**: fit-for-surface UI verification (integration/E2E, smoke, manual, or visual checks as appropriate)");
+  } else if (options?.testMethodologyHint === TEST_METHODOLOGY_HINTS.STRUCTURED_CONTENT) {
+    lines.push("- **Testing**: structured-content verification (fixtures, schema, golden data, or integration checks as appropriate)");
+  } else {
+    const testingStatus = policy.tests_required ? "required" : "optional";
+    lines.push(`- **Testing**: ${policy.testing} (tests ${testingStatus})`);
+  }
+  if (usesNonTddSummaryHint(options)) {
+    const modeLabel = policy.coverage_mode === "block" ? "blocking" : policy.coverage_mode === "warn" ? "warn only" : "disabled";
+    lines.push(`- **Coverage**: ${policy.coverage_threshold}% policy target (${modeLabel}) when automated application tests apply`);
+  } else if (policy.coverage_mode === "off") {
+    lines.push("- **Coverage**: disabled");
+  } else {
+    const modeLabel = policy.coverage_mode === "block" ? "blocking" : "warn only";
+    lines.push(`- **Coverage**: ${policy.coverage_threshold}% (${modeLabel})`);
+  }
+  if (policy.architecture !== "none") {
+    lines.push(`- **Architecture**: ${policy.architecture}`);
+  }
+  return lines.join("\n");
+}
+
+export {
+  TEST_METHODOLOGY_HINTS,
+  classifyWork,
+  generateCodeCraftGuidance,
+  generateReadBeforeWriteDiscipline,
+  generateSelfReviewDirective,
+  generateMandatoryStandards,
+  generatePolicyBasedTestGuidance,
+  generateDesignContextSection,
+  generateEnforcementSummary
+};