swarm-orchestrator 7.0.0-alpha.0

package/dist/src/prompt-builder.js

@@ -0,0 +1,173 @@
+"use strict";
+// Extracted prompt-building and shared-instruction helpers (formerly class methods on SwarmOrchestrator).
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSwarmPrompt = buildSwarmPrompt;
+exports.writeSharedInstructions = writeSharedInstructions;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const baseline_scanner_1 = require("./baseline-scanner");
+const logger_1 = require("./logger");
+const test_command_discovery_1 = require("./test-command-discovery");
+const logger = (0, logger_1.getLogger)('prompt-builder');
+/**
+ * Build the per-step prompt that gets sent to the Copilot CLI agent.
+ */
+function buildSwarmPrompt(step, agent, context, dependencyContext) {
+    const sections = [];
+    sections.push(`Step ${step.stepNumber}/${context.plan.steps.length} | Agent: ${agent.name}`);
+    sections.push(`Role: ${agent.purpose}\n`);
+    sections.push('TASK:');
+    sections.push(step.task + '\n');
+    if (dependencyContext && dependencyContext.trim().length > 0) {
+        sections.push('DEPENDENCY CONTEXT:');
+        sections.push(dependencyContext + '\n');
+    }
+    sections.push('BRANCH: you are already on your correct branch in a dedicated git worktree.');
+    sections.push('Do NOT run git checkout or switch branches.\n');
+    sections.push('Scope (what you ARE responsible for):');
+    agent.scope.forEach(item => sections.push('- ' + item));
+    sections.push('');
+    sections.push('Boundaries (what you must NOT do):');
+    agent.boundaries.forEach(item => sections.push('- ' + item));
+    sections.push('');
+    // Surface existing test files so agents know what they must not break.
+    // Full preservation rules live in .copilot-instructions.md; this is a
+    // per-step reminder with the actual filenames.
+    const baseline = context.baselineSnapshot;
+    if (baseline && baseline.testFiles.length > 0) {
+        sections.push('EXISTING TESTS (must still pass after your changes):');
+        for (const f of baseline.testFiles) {
+            sections.push('- ' + f);
+        }
+        sections.push('Do NOT modify, delete, or rewrite any test files. Only edit source code.');
+        sections.push('Test files are verified by an external harness and your edits will cause patch conflicts.');
+        sections.push('');
+    }
+    sections.push('Done when:');
+    agent.done_definition.forEach(item => sections.push('- ' + item));
+    sections.push('');
+    if (agent.refusal_rules.length > 0) {
+        sections.push('Refusal rules (stop and explain instead of proceeding):');
+        agent.refusal_rules.forEach(rule => sections.push('- ' + rule));
+        sections.push('');
+    }
+    // Hard rules, quality standards, git/comment conventions live in
+    // .copilot-instructions.md (written once per run). Not duplicated here
+    // to keep prompt tokens low and avoid double-loading by Claude Code.
+    sections.push('Expected outputs:');
+    step.expectedOutputs.forEach(output => sections.push('- ' + output));
+    sections.push('');
+    // Discover the target project's real test gate (pnpm/npm/yarn test) so the
+    // agent runs the full script rather than picking a subset like
+    // `npx vitest --run`, which masks lint/type-check failures.
+    const testDiscovery = (0, test_command_discovery_1.discoverTestCommand)(context.targetProjectRoot || process.cwd());
+    if (testDiscovery.warning) {
+        // Diagnostic only: the fallback to `npm test` is correct in 99% of repos
+        // and not actionable for the user. Surfaces on stderr with --verbose.
+        logger.debug(`test command discovery: ${testDiscovery.warning}`);
+    }
+    sections.push((0, test_command_discovery_1.renderVerifyCommandSection)(testDiscovery));
+    return sections.join('\n');
+}
+/**
+ * Write `.copilot-instructions.md` into the working directory so every
+ * worktree / agent inherits shared rules via a single committed file.
+ */
+function writeSharedInstructions(workingDir, baseline, tierInjection) {
+    const instructionsPath = path.join(workingDir, '.copilot-instructions.md');
+    // Only write if the file does not already exist (avoid overwriting user content)
+    if (fs.existsSync(instructionsPath))
+        return;
+    const contentParts = [
+        '# Swarm Agent Instructions',
+        '',
+        '## Parallel Execution Context',
+        'You are running inside a git worktree on a dedicated branch. Do NOT run `git checkout`.',
+        'Make incremental commits with natural, varied messages.',
+        '',
+        '## Hard Rules',
+        '- Do not invent features, flags, APIs, or tool behavior not in your task.',
+        '- Do not claim tests passed unless you ran them and can show the output.',
+        '- Do not say "done" unless all required artifacts exist and you verified them.',
+        '- If uncertain about anything, say so explicitly.',
+        '- Never reference files, images, fonts, or assets that do not exist in the repo.',
+        '- Encapsulate JS: wrap in IIFE, module, or DOMContentLoaded. No bare globals in script scope.',
+        '',
+    ];
+    // Tier-filtered requirements replace the old flat "Quality Bar" section.
+    // Only requirements relevant to the detected task type get injected.
+    if (tierInjection && tierInjection.trim().length > 0) {
+        contentParts.push(tierInjection);
+        contentParts.push('');
+    }
+    // Pin the target project's real test gate into the shared instructions so
+    // every agent that inherits this file knows which single command to run
+    // instead of reaching for a subset runner like `npx vitest --run`.
+    const testDiscovery = (0, test_command_discovery_1.discoverTestCommand)(workingDir);
+    if (testDiscovery.warning) {
+        logger.debug(`test command discovery (shared instructions): ${testDiscovery.warning}`);
+    }
+    contentParts.push('## Verify Before Committing', `Before committing, run \`${testDiscovery.command}\` and verify it passes.`, 'Do not run individual test tools directly. Run the project\'s full test script.');
+    if (testDiscovery.hasScript && testDiscovery.rawScript) {
+        contentParts.push(`This project's "${testDiscovery.command}" runs: ${testDiscovery.rawScript}`, 'Running a subset (e.g. `npx vitest --run`) will miss lint and type checks and your commit may fail.');
+    }
+    else if (testDiscovery.warning) {
+        contentParts.push(`WARNING: ${testDiscovery.warning}`);
+    }
+    contentParts.push('');
+    contentParts.push('## Quality Bar', '- Code reads as human-written. No AI-typical patterns: no over-commented obvious logic, no generic variable names, no boilerplate filler.', '- Extract before repeat: if you copy the same logic more than twice, refactor into a shared util/hook/middleware.', '- Config first: do not hardcode API base URLs, timeouts, retry counts, or environment-specific values.', '- README truth: do not claim features that are not implemented. Do not add sections that do not apply (no troubleshooting tables for trivial projects).', '- Error messages must be specific and actionable with relevant values.', '', '## Code Comments', '- Add a 1-2 line purpose comment at the top of each new file.', '- Add brief inline comments for non-obvious logic (not every line).', '- Use natural, casual language. Good: "// bail early if empty". Bad: "// Check if the array has zero length".', '', '## Commit Messages', 'Use varied, natural messages like:', '  "add user authentication module"', '  "fix: handle null case in parser"', '  "update config and deps"', '  "implement todo API with tests"', '');
+    // Append baseline preservation rules when the repo has existing files
+    if (baseline && baseline.allFiles.length > 0) {
+        const rules = (0, baseline_scanner_1.formatPreservationRules)(baseline);
+        if (rules)
+            contentParts.push(rules);
+    }
+    const content = contentParts.join('\n');
+    fs.writeFileSync(instructionsPath, content, 'utf8');
+    // Commit so worktrees (branched from main) inherit the instructions file
+    try {
+        (0, child_process_1.execSync)('git add .copilot-instructions.md', { cwd: workingDir, stdio: 'pipe' });
+        (0, child_process_1.execSync)('git commit -m "add shared copilot instructions for swarm agents"', {
+            cwd: workingDir, stdio: 'pipe',
+            env: { ...process.env, GIT_TERMINAL_PROMPT: '0' },
+        });
+    }
+    catch {
+        // Commit may fail if repo has no initial commit yet; non-fatal
+        logger.warn('Could not commit .copilot-instructions.md (non-fatal)');
+    }
+}

package/dist/src/quality-gates/config-loader.js

@@ -0,0 +1,196 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.load_quality_gates_config = load_quality_gates_config;
+const fs = __importStar(require("fs"));
+const yaml = __importStar(require("js-yaml"));
+const path = __importStar(require("path"));
+const default_config_1 = require("./default-config");
+const registry_1 = require("./registry");
+const logger_1 = require("../logger");
+const logger = (0, logger_1.getLogger)('quality-gates:config');
+function is_object(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+/**
+ * Convert kebab-case identifiers (e.g. `duplicate-blocks`) to the camelCase
+ * canonical form the registry stores (`duplicateBlocks`). Identifiers that
+ * are already camelCase pass through unchanged. This bridges the README's
+ * Quality gates table (which displays kebab) and `.swarm/gates.yaml`
+ * (which historically required camel).
+ */
+function kebab_to_camel(key) {
+    return key.replace(/-([a-z])/g, (_match, ch) => ch.toUpperCase());
+}
+/**
+ * Normalize the `gates` map so callers can write either kebab-case
+ * (`runtime-checks`) or camelCase (`runtimeChecks`) keys in YAML. Mutates a
+ * fresh copy of the parsed config; the original object is not altered.
+ * Throws if the same gate is configured under both spellings, since the
+ * intent is ambiguous.
+ */
+function normalize_gate_keys(parsed, sourcePath) {
+    const gates = parsed.gates;
+    if (!is_object(gates))
+        return;
+    const normalized = {};
+    for (const rawKey of Object.keys(gates)) {
+        const camelKey = kebab_to_camel(rawKey);
+        if (Object.prototype.hasOwnProperty.call(normalized, camelKey)) {
+            throw new Error(`Duplicate gate config in ${sourcePath}: "${rawKey}" collides with another spelling that resolves to "${camelKey}". Use one form, not both.`);
+        }
+        normalized[camelKey] = gates[rawKey];
+    }
+    parsed.gates = normalized;
+}
+/**
+ * Validate that all gate keys in a user-provided config are recognized.
+ * Throws a descriptive error listing valid names when unknown keys are found.
+ * Runs after `normalize_gate_keys`, so the validation set is the camelCase
+ * registry keys.
+ * @param parsed - The parsed YAML object (already normalized)
+ * @param sourcePath - File path for error messages
+ */
+function validate_gate_keys(parsed, sourcePath) {
+    const gates = parsed.gates;
+    if (!is_object(gates))
+        return;
+    const validKeys = new Set((0, registry_1.getRegisteredGateKeys)());
+    const unknownKeys = Object.keys(gates).filter(k => !validKeys.has(k));
+    if (unknownKeys.length > 0) {
+        const validList = (0, registry_1.getRegisteredGateKeys)().sort().join(', ');
+        throw new Error(`Unknown gate key(s) in ${sourcePath}: ${unknownKeys.join(', ')}. ` +
+            `Valid gate keys: ${validList}`);
+    }
+}
+function merge_config(base, override) {
+    const mergedGates = {
+        ...base.gates,
+        ...(override.gates || {})
+    };
+    for (const gate of (0, registry_1.getRegisteredGates)()) {
+        mergedGates[gate.key] = {
+            ...(base.gates[gate.key] || gate.defaultConfig),
+            ...(override.gates?.[gate.key] || {})
+        };
+    }
+    const merged = {
+        ...base,
+        ...override,
+        gates: mergedGates
+    };
+    return merged;
+}
+/**
+ * Load a YAML config file, validate it, and return the parsed object.
+ * Throws on YAML syntax errors with the file path in the message.
+ * @param filePath - Absolute path to the YAML file
+ * @returns Parsed config as a partial QualityGatesConfig
+ */
+function load_yaml_config(filePath) {
+    const raw = fs.readFileSync(filePath, 'utf8');
+    let parsed;
+    try {
+        parsed = yaml.load(raw);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        throw new Error(`YAML syntax error in ${filePath}: ${msg}`, { cause: err });
+    }
+    if (!parsed || (is_object(parsed) && Object.keys(parsed).length === 0)) {
+        return {};
+    }
+    if (!is_object(parsed)) {
+        throw new Error(`Quality gates config must be a YAML object: ${filePath}`);
+    }
+    normalize_gate_keys(parsed, filePath);
+    validate_gate_keys(parsed, filePath);
+    return parsed;
+}
+/**
+ * Resolve quality gate configuration using a three-layer merge strategy:
+ * 1. Built-in defaults
+ * 2. Per-project `.swarm/gates.yaml` (if present in repoRoot)
+ * 3. Explicit path from `--quality-gates-config` flag (if provided)
+ *
+ * Unknown gate keys in user-provided configs cause a descriptive error.
+ * YAML syntax errors surface with the file path included.
+ *
+ * @param projectRoot - Root directory of the target repository
+ * @param explicitPath - Optional explicit config path from CLI flag
+ * @returns Fully resolved quality gates configuration
+ */
+function load_quality_gates_config(projectRoot, explicitPath) {
+    const projectGateSources = (0, registry_1.loadProjectGateRegistrations)(projectRoot);
+    for (const source of projectGateSources) {
+        logger.debug(`loaded project gate registration from ${source}`);
+    }
+    // Start with a defensive copy so callers never mutate the shared default
+    let config = merge_config(default_config_1.DEFAULT_QUALITY_GATES_CONFIG, {});
+    // Layer 2: per-project .swarm/gates.yaml
+    const perProjectPath = path.join(projectRoot, '.swarm', 'gates.yaml');
+    if (fs.existsSync(perProjectPath)) {
+        logger.debug(`loading gate config ${perProjectPath}`);
+        const perProject = load_yaml_config(perProjectPath);
+        if (Object.keys(perProject).length > 0) {
+            config = merge_config(config, perProject);
+        }
+    }
+    // Layer 3: explicit path from --quality-gates-config flag
+    if (explicitPath) {
+        const resolved = path.isAbsolute(explicitPath) ? explicitPath : path.join(projectRoot, explicitPath);
+        if (!fs.existsSync(resolved)) {
+            throw new Error(`Quality gates config file not found: ${resolved}`);
+        }
+        logger.debug(`loading explicit gate config ${resolved}`);
+        const explicit = load_yaml_config(resolved);
+        if (Object.keys(explicit).length > 0) {
+            config = merge_config(config, explicit);
+        }
+    }
+    // Legacy fallback: config/quality-gates.yaml in the project root
+    // Only applies when neither .swarm/gates.yaml nor explicit path was used
+    if (!explicitPath && !fs.existsSync(perProjectPath)) {
+        const legacyPath = path.join(projectRoot, 'config', 'quality-gates.yaml');
+        if (fs.existsSync(legacyPath)) {
+            logger.debug(`loading legacy gate config ${legacyPath}`);
+            const legacy = load_yaml_config(legacyPath);
+            if (Object.keys(legacy).length > 0) {
+                config = merge_config(config, legacy);
+            }
+        }
+    }
+    return config;
+}

package/dist/src/quality-gates/default-config.js

@@ -0,0 +1,243 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_QUALITY_GATES_CONFIG = void 0;
+exports.DEFAULT_QUALITY_GATES_CONFIG = {
+    enabled: true,
+    failOnIssues: true,
+    autoAddRefactorStepOnDuplicateBlocks: true,
+    autoAddReadmeTruthStepOnReadmeClaims: true,
+    autoAddScaffoldFixStepOnScaffoldDefaults: true,
+    autoAddConfigFixStepOnHardcodedConfig: true,
+    autoAddAccessibilityFixStepOnAccessibility: true,
+    autoAddTestCoverageStepOnTestCoverage: true,
+    excludeDirNames: [
+        '.git',
+        'node_modules',
+        'dist',
+        'build',
+        'coverage',
+        '.next',
+        '.turbo',
+        '.cache',
+        '.context',
+        '.locks',
+        'runs',
+        'plans',
+        'proof',
+        '.quickfix',
+        'fixtures',
+        // Python virtual environments and build artifacts
+        'venv',
+        '.venv',
+        'env',
+        '.env',
+        '__pycache__',
+        '.tox',
+        '.mypy_cache',
+        '.pytest_cache',
+        '.ruff_cache',
+        '.eggs',
+        'site-packages',
+        // Ruby / Rust / Go / Java build dirs
+        'vendor',
+        'target',
+        '.gradle',
+        // IDE and OS artifacts
+        '.idea',
+        '.vscode',
+        '.vs'
+    ],
+    maxFileSizeBytes: 512 * 1024,
+    gates: {
+        scaffoldDefaults: {
+            enabled: true,
+            bannedTitleRegexes: [
+                'Vite \\+ React',
+                'React App',
+                'Next\\.js App',
+                'SvelteKit'
+            ],
+            bannedReadmeRegexes: [
+                'This project was bootstrapped with',
+                'Vite\\s+\\+\\s+React',
+                'Create React App'
+            ],
+            bannedFiles: [
+                'public/vite.svg',
+                'src/logo.svg',
+                'public/favicon.ico'
+            ]
+        },
+        duplicateBlocks: {
+            enabled: true,
+            minLines: 12,
+            maxOccurrences: 2,
+            maxFindings: 20,
+            excludeFileRegexes: [
+                '^package-lock\\.json$',
+                '^pnpm-lock\\.yaml$',
+                '^yarn\\.lock$',
+                '^test-output\\.txt$',
+                '^dist/',
+                '^build/',
+                '^coverage/',
+                '^runs/',
+                '^plans/',
+                '^proof/',
+                '^venv/',
+                '^\\.venv/',
+                '^env/',
+                '^vendor/',
+                '^target/',
+                '^__pycache__/'
+            ]
+        },
+        hardcodedConfig: {
+            enabled: true,
+            bannedLiteralRegexes: [
+                'https?://localhost(?::\\d+)?',
+                'https?://127\\.0\\.0\\.1(?::\\d+)?',
+                'RETRY_COUNT\\s*=\\s*[0-9]+'
+            ],
+            allowIfFileContainsRegexes: [
+                'process\\.env\\.',
+                'import\\.meta\\.env',
+                'window\\.__CONFIG__'
+            ],
+            excludeFileRegexes: [
+                '^\.github/',
+                '\\.(md|mdx)$',
+                '^dist/',
+                '^build/',
+                '^coverage/',
+                '^runs/',
+                '^plans/',
+                '^proof/',
+                '^venv/',
+                '^\\.venv/',
+                '^env/',
+                '^vendor/',
+                '^target/',
+                '^__pycache__/',
+                '^benchmarks/',
+                '^test/fixtures/',
+                '(^|/)tests?/',
+                '(^|/)__tests__/',
+                '\\.(test|spec)\\.(ts|js|tsx|jsx|mjs)$',
+                '(^|/)test_[^/]*\\.py$',
+                '^(integration|e2e)[.-]',
+                '^test\\.(js|ts|mjs)$',
+                '^tests\\.(js|ts|mjs)$',
+                '^(deploy|scripts)/',
+                '\\.(sh|bash|bat|cmd|ps1)$',
+                'vite\\.config\\.(js|ts|mjs|mts)$',
+                'webpack\\.config\\.(js|ts)$',
+                '\\.env(\\.example|\\.local)?$',
+                '^docker-compose[^/]*\\.ya?ml$',
+                '(^|/)Dockerfile',
+                '\\.dockerfile$'
+            ]
+        },
+        readmeClaims: {
+            enabled: true,
+            claimRules: [
+                {
+                    id: 'claim-retry',
+                    readmeRegex: '\\b(retry|retries|backoff|exponential backoff)\\b',
+                    requiredEvidence: [
+                        { fileRegex: 'src/.+', contentRegex: '\\bretry\\b', note: 'expected a retry helper or implementation' }
+                    ]
+                },
+                {
+                    id: 'claim-optimistic-ui',
+                    readmeRegex: '\\boptimistic\\b',
+                    requiredEvidence: [
+                        { fileRegex: 'src/.+', contentRegex: '\\boptimistic\\b', note: 'expected optimistic UI implementation' }
+                    ]
+                },
+                {
+                    id: 'claim-correlation-id',
+                    readmeRegex: '\\bcorrelation id\\b|\\bx-correlation-id\\b',
+                    requiredEvidence: [
+                        { fileRegex: 'src/.+', contentRegex: 'x-correlation-id|correlationId', note: 'expected correlation ID support in code' }
+                    ]
+                },
+                {
+                    id: 'claim-request-logging',
+                    readmeRegex: '\\brequest logging\\b|\\blog requests\\b',
+                    requiredEvidence: [
+                        { fileRegex: 'src/.+', contentRegex: 'req\\.method|morgan', note: 'expected request logging middleware' }
+                    ]
+                }
+            ]
+        },
+        testIsolation: {
+            enabled: true,
+            mutableStoreRegexes: [
+                '^\\s*let\\s+\\w+\\s*=\\s*\\[\\s*\\]\\s*;\\s*$',
+                '^\\s*let\\s+\\w+\\s*=\\s*\\{\\s*\\}\\s*;\\s*$'
+            ],
+            allowIfFileContainsRegexes: [
+                'resetForTests',
+                '__reset',
+                'clearAll',
+                'beforeEach\\('
+            ],
+            testFileRegexes: [
+                '^(test|tests)/.+\\.test\\.(ts|js|tsx|jsx)$',
+                '^__tests__/.+\\.(ts|js|tsx|jsx)$',
+                '\\.test\\.(ts|js|tsx|jsx)$',
+                '\\.spec\\.(ts|js|tsx|jsx)$'
+            ],
+            allowIfAnyTestContainsRegexes: [
+                'beforeEach\\(',
+                'afterEach\\('
+            ]
+        },
+        runtimeChecks: {
+            enabled: true,
+            retries: 1,
+            runTests: true,
+            runLint: true,
+            runAudit: true,
+            timeoutMs: 120000
+        },
+        accessibility: {
+            enabled: true,
+            requireSkipLink: true,
+            requireHeadingHierarchy: true,
+            requireAriaLabels: true,
+            requireFocusStyles: true,
+            requireReducedMotion: true,
+            requireNoPhantomAssets: true,
+            requireMetaTags: true,
+            requireResponsiveCSS: true,
+            requireColorScheme: true,
+            requireSemanticHTML: true,
+            requireImgAlt: true
+        },
+        testCoverage: {
+            enabled: true,
+            entryPointPatterns: [],
+            minTestAssertions: 1,
+            requireComponentTests: true
+        },
+        testFileProtection: {
+            enabled: true,
+            testFileGlobs: [
+                'tests/**',
+                'test/**',
+                '**/__tests__/**',
+                '**/*.test.ts',
+                '**/*.test.tsx',
+                '**/*.test.js',
+                '**/*.test.jsx',
+                '**/*.spec.ts',
+                '**/*.spec.js',
+                '**/test_*.py',
+                '**/*_test.py'
+            ],
+            maxFindings: 25
+        }
+    }
+};