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