swarm-orchestrator 7.0.0-alpha.0

package/dist/src/quality-gates/gates/test-coverage.js

@@ -0,0 +1,240 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run_test_coverage_gate = run_test_coverage_gate;
+const file_utils_1 = require("../file-utils");
+// Patterns that indicate a file is an entry point (not a standalone module needing its own test).
+// The (^|\/) prefix handles monorepo layouts like frontend/src/main.jsx alongside flat src/main.tsx.
+const DEFAULT_ENTRY_PATTERNS = [
+    /(^|\/)src\/(main|index)\.(tsx?|jsx?|mjs)$/,
+    /(^|\/)src\/app\.(tsx?|jsx?)$/i
+];
+async function run_test_coverage_gate(ctx, config, maxFileSizeBytes) {
+    const start = Date.now();
+    const issues = [];
+    // Custom patterns extend the structural defaults (main/index/app are always
+    // entry points regardless of project config), not replace them.
+    const customPatterns = config.entryPointPatterns.map(p => new RegExp(p, 'i'));
+    const entryPatterns = [...DEFAULT_ENTRY_PATTERNS, ...customPatterns];
+    // Identify source files that should have tests
+    const sourceFiles = ctx.files.filter(f => {
+        if (!/\.(tsx?|jsx?|mjs)$/i.test(f.relativePath))
+            return false;
+        if (/^(test|tests|__tests__)\//.test(f.relativePath))
+            return false;
+        if (/\.test\.|\.spec\./.test(f.relativePath))
+            return false;
+        // Root-level test scripts (test.js, tests.js) are test files, not source
+        if (/^tests?\.(tsx?|jsx?|mjs)$/i.test(f.relativePath))
+            return false;
+        // Integration/e2e test files at root level
+        if (/^(integration|e2e)[.-]/i.test(f.relativePath))
+            return false;
+        if (/^(server|config|scripts|examples?|deploy|benchmarks)\//.test(f.relativePath))
+            return false;
+        // Test setup/config files nested inside src/ (e.g. src/test/setup.js,
+        // src/setupTests.ts, frontend/src/test/setup.js) are test infrastructure
+        if (/\btest\/setup\b|\bsetup[Tt]ests?\b|\btestSetup\b/i.test(f.relativePath))
+            return false;
+        // Exclude standalone server entry points (e.g. src/server.js that just calls app.listen)
+        if (/\bserver\.(tsx?|jsx?|mjs)$/i.test(f.relativePath))
+            return false;
+        // Exclude vite/webpack configs and similar build tooling
+        if (/\.(config|d)\.(ts|js|mjs)$/i.test(f.relativePath))
+            return false;
+        // Exclude root-level entry scripts (start-*, index.js, app.js) outside src/
+        if (!/\//.test(f.relativePath) || /^[^/]+\.(js|mjs)$/.test(f.relativePath)) {
+            if (/^(start|launch|boot|serve)[-.]/i.test(f.relativePath))
+                return false;
+        }
+        // Exclude entry points
+        if (entryPatterns.some(p => p.test(f.relativePath)))
+            return false;
+        // Exclude Ink TUI components: .tsx files importing from 'ink' are terminal UI
+        // renderers that require ink-testing-library, not standard DOM test utilities.
+        // Coverage comes from integration tests that exercise the underlying data model.
+        if (/\.tsx$/i.test(f.relativePath)) {
+            const text = f.text ?? (0, file_utils_1.maybe_read_text)(f, maxFileSizeBytes);
+            if (text && /from\s+['"]ink['"]|require\s*\(\s*['"]ink['"]\)/.test(text)) {
+                return false;
+            }
+        }
+        return true;
+    });
+    // Identify test files: convention-named (.test./.spec.) and root-level test scripts
+    const testFiles = ctx.files.filter(f => /\.(test|spec)\.(tsx?|jsx?|mjs)$/i.test(f.relativePath) ||
+        /^tests?\.(tsx?|jsx?|mjs)$/i.test(f.relativePath));
+    // Collect all require/import edges from every source and test file so we
+    // can resolve transitive coverage. An integration test importing app.js
+    // should count as covering the controllers, middleware, and routes that
+    // app.js itself requires.
+    const allFiles = [...ctx.files];
+    const fileImports = new Map();
+    const importRegex = /(?:from\s+['"]|require\s*\(\s*['"])([^'"]+)['"]/g;
+    // Resolve a relative import specifier against the importing file's directory
+    function resolveImport(specifier, importerRelPath) {
+        const stripped = specifier.replace(/\.(js|ts|jsx|tsx|mjs)$/, '');
+        if (!specifier.startsWith('.'))
+            return stripped;
+        const importerKey = importerRelPath.replace(/\.(js|ts|jsx|tsx|mjs)$/, '');
+        const slashIdx = importerKey.lastIndexOf('/');
+        let dir = slashIdx >= 0 ? importerKey.substring(0, slashIdx) : '';
+        let remaining = stripped;
+        if (remaining.startsWith('./')) {
+            remaining = remaining.substring(2);
+        }
+        else {
+            while (remaining.startsWith('../')) {
+                remaining = remaining.substring(3);
+                const parentSlash = dir.lastIndexOf('/');
+                dir = parentSlash >= 0 ? dir.substring(0, parentSlash) : '';
+            }
+        }
+        return dir ? `${dir}/${remaining}` : remaining;
+    }
+    for (const f of allFiles) {
+        if (!/\.(tsx?|jsx?|mjs)$/i.test(f.relativePath))
+            continue;
+        const text = f.text ?? (0, file_utils_1.maybe_read_text)(f, maxFileSizeBytes);
+        if (!text)
+            continue;
+        const imports = [];
+        let m;
+        importRegex.lastIndex = 0;
+        while ((m = importRegex.exec(text)) !== null) {
+            if (!m[1].startsWith('.'))
+                continue;
+            imports.push(resolveImport(m[1], f.relativePath));
+        }
+        const key = f.relativePath.replace(/\.(js|ts|jsx|tsx|mjs)$/, '');
+        fileImports.set(key, imports);
+        // Register barrel alias: directory imports resolve to dir/index
+        const basename = key.split('/').pop();
+        if (basename === 'index') {
+            const dirKey = key.replace(/\/index$/, '');
+            fileImports.set(dirKey, imports);
+        }
+    }
+    // Walk transitive imports from test files to build the full coverage set
+    const importedByTests = new Set();
+    function walkImports(moduleKey, visited) {
+        if (visited.has(moduleKey))
+            return;
+        visited.add(moduleKey);
+        importedByTests.add(moduleKey);
+        const deps = fileImports.get(moduleKey) || fileImports.get(`src/${moduleKey}`) || [];
+        for (const dep of deps) {
+            walkImports(dep, visited);
+            // Also try with src/ prefix
+            if (!dep.startsWith('src/')) {
+                walkImports(`src/${dep}`, visited);
+            }
+        }
+    }
+    for (const tf of testFiles) {
+        const text = tf.text ?? (0, file_utils_1.maybe_read_text)(tf, maxFileSizeBytes);
+        if (!text)
+            continue;
+        importRegex.lastIndex = 0;
+        let match;
+        while ((match = importRegex.exec(text)) !== null) {
+            if (!match[1].startsWith('.'))
+                continue;
+            const resolved = resolveImport(match[1], tf.relativePath);
+            walkImports(resolved, new Set());
+        }
+    }
+    // 1. Check that each source file has a corresponding test or is imported by a test.
+    //    Only flag files created by agents; pre-existing files are the project owner's concern.
+    for (const src of sourceFiles) {
+        if (ctx.baselineFiles?.has(src.relativePath))
+            continue;
+        const baseName = src.relativePath
+            .replace(/^src\//, '')
+            .replace(/\.(tsx?|jsx?|mjs)$/, '');
+        const hasDirectTest = testFiles.some(tf => {
+            const testBase = tf.relativePath
+                .replace(/^(test|tests|__tests__)\//, '')
+                .replace(/^(unit|integration|e2e)\//, '')
+                .replace(/\.(test|spec)\.(tsx?|jsx?|mjs)$/, '');
+            // Match by full relative path, by stripping common prefixes, or
+            // by filename only (test/unit/foo.test.js covers src/services/foo.js)
+            const testBaseName = testBase.split('/').pop() || testBase;
+            const srcBaseName = baseName.split('/').pop() || baseName;
+            return testBase === baseName
+                || testBase === baseName.replace(/^utils\//, '')
+                || testBaseName === srcBaseName;
+        });
+        const isImportedByTest = importedByTests.has(`src/${baseName}`) ||
+            importedByTests.has(baseName) ||
+            importedByTests.has(src.relativePath.replace(/\.(tsx?|jsx?|mjs)$/, ''));
+        if (!hasDirectTest && !isImportedByTest) {
+            issues.push({
+                message: `no test coverage for ${src.relativePath}`,
+                filePath: src.relativePath,
+                hint: `create a test file or import ${src.relativePath} in an existing test`
+            });
+        }
+    }
+    // 2. Check that test files contain real assertions (not empty stubs).
+    //    Only validate agent-created test files, not pre-existing ones.
+    for (const tf of testFiles) {
+        if (ctx.baselineFiles?.has(tf.relativePath))
+            continue;
+        const text = tf.text ?? (0, file_utils_1.maybe_read_text)(tf, maxFileSizeBytes);
+        if (!text)
+            continue;
+        const assertionPatterns = /\b(assert\.|expect\(|\.toBe|\.toEqual|\.toThrow|\.ok\(|\.strictEqual|\.deepEqual|\.deepStrictEqual|\.match\(|\.rejects|\.resolves)/;
+        const assertionCount = (text.match(new RegExp(assertionPatterns.source, 'g')) || []).length;
+        if (assertionCount < config.minTestAssertions) {
+            issues.push({
+                message: `${tf.relativePath} has ${assertionCount} assertion(s), minimum is ${config.minTestAssertions}`,
+                filePath: tf.relativePath,
+                hint: 'add meaningful assertions that verify module behavior'
+            });
+        }
+    }
+    // 3. Check for component-level tests in React projects
+    // Skip for Ink (terminal UI) projects where DOM testing libraries don't apply.
+    if (config.requireComponentTests) {
+        const isReactProject = ctx.files.some(f => {
+            const text = f.text ?? (0, file_utils_1.maybe_read_text)(f, maxFileSizeBytes);
+            if (!text)
+                return false;
+            return /from\s+['"]react['"]|require\s*\(\s*['"]react['"]\)/.test(text);
+        });
+        const isInkProject = ctx.files.some(f => {
+            const text = f.text ?? (0, file_utils_1.maybe_read_text)(f, maxFileSizeBytes);
+            if (!text)
+                return false;
+            return /from\s+['"]ink['"]|require\s*\(\s*['"]ink['"]\)/.test(text);
+        });
+        if (isReactProject && !isInkProject) {
+            const hasComponentTest = testFiles.some(f => {
+                const text = f.text ?? (0, file_utils_1.maybe_read_text)(f, maxFileSizeBytes);
+                if (!text)
+                    return false;
+                return /(render\s*\(|screen\.|document\.|getBy|queryBy|findBy|innerHTML|textContent|@testing-library)/i.test(text);
+            });
+            if (!hasComponentTest) {
+                issues.push({
+                    message: 'React project has no component-level tests',
+                    hint: 'add at least one test that renders a component and asserts DOM output'
+                });
+            }
+        }
+    }
+    const durationMs = Date.now() - start;
+    const status = issues.length > 0 ? 'fail' : 'pass';
+    return {
+        id: 'test-coverage',
+        title: 'Test coverage checks',
+        status,
+        durationMs,
+        issues,
+        stats: {
+            sourceFiles: sourceFiles.length,
+            testFiles: testFiles.length,
+            issues: issues.length
+        }
+    };
+}

package/dist/src/quality-gates/gates/test-file-protection.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run_test_file_protection_gate = run_test_file_protection_gate;
+const child_process_1 = require("child_process");
+/**
+ * D4: Test-File Protection Gate
+ *
+ * Detects when an agent has **modified** (not added) pre-existing test files.
+ * Agents should write new tests, not weaken existing ones.
+ *
+ * Uses `git diff --name-only --diff-filter=M` against a base commit
+ * and matches the results against configurable test-file patterns.
+ */
+async function run_test_file_protection_gate(projectRoot, config, baseCommit) {
+    const start = Date.now();
+    const issues = [];
+    const base = baseCommit || 'HEAD~1';
+    const patterns = config.testFileGlobs;
+    try {
+        // Get all MODIFIED (not Added) files relative to the base commit
+        const raw = (0, child_process_1.execSync)(`git diff --name-only --diff-filter=M ${base}`, { cwd: projectRoot, encoding: 'utf8', timeout: 30_000, stdio: ['ignore', 'pipe', 'pipe'] }).trim();
+        if (raw.length === 0) {
+            return result('pass', issues, Date.now() - start, 0);
+        }
+        const modifiedFiles = raw.split('\n').filter(Boolean);
+        // Compile glob-like patterns to regexes
+        const matchers = patterns.map(glob_to_regex);
+        let flagged = 0;
+        for (const file of modifiedFiles) {
+            if (matchers.some(re => re.test(file))) {
+                flagged++;
+                issues.push({
+                    message: `Pre-existing test file was modified by an agent`,
+                    filePath: file,
+                    hint: 'Agents should add new test files, not modify existing ones. ' +
+                        'If the modification is fixing an import path or test config, ' +
+                        'consider an allowlist entry in quality-gates.yaml.'
+                });
+                if (issues.length >= (config.maxFindings ?? 25))
+                    break;
+            }
+        }
+        const status = issues.length > 0 ? 'fail' : 'pass';
+        return result(status, issues, Date.now() - start, flagged);
+    }
+    catch (err) {
+        // git not available or not a repo — skip gracefully
+        const msg = err instanceof Error ? err.message : String(err);
+        return {
+            id: 'test-file-protection',
+            title: 'Test files not modified by agents',
+            status: 'skip',
+            durationMs: Date.now() - start,
+            issues: [{
+                    message: `Could not run git diff: ${msg.slice(0, 200)}`,
+                    hint: 'Ensure the project is a git repo with at least one commit.'
+                }],
+            stats: { flagged: 0 }
+        };
+    }
+}
+function result(status, issues, durationMs, flagged) {
+    return {
+        id: 'test-file-protection',
+        title: 'Test files not modified by agents',
+        status,
+        durationMs,
+        issues,
+        stats: { flagged }
+    };
+}
+/**
+ * Convert a simple glob pattern to a RegExp.
+ * Supports: ** (any path), * (any segment chars), ? (single char).
+ * Patterns are matched against the full relative path.
+ */
+function glob_to_regex(glob) {
+    const re = glob
+        .replace(/[.+^${}()|[\]\\]/g, '\\$&') // escape regex specials (except * and ?)
+        .replace(/\*\*/g, '$$GLOBSTAR$$') // placeholder for **
+        .replace(/\*/g, '[^/]*') // * = anything except /
+        .replace(/\?/g, '.') // ? = single char
+        .replace(/\$\$GLOBSTAR\$\$/g, '.*'); // ** = anything including /
+    return new RegExp(`^${re}$`, 'i');
+}

package/dist/src/quality-gates/gates/test-isolation.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run_test_isolation_gate = run_test_isolation_gate;
+const file_utils_1 = require("../file-utils");
+function is_probably_source_file(relPath) {
+    return /\.(ts|js|tsx|jsx)$/.test(relPath) && !/\.d\.ts$/.test(relPath);
+}
+async function run_test_isolation_gate(ctx, config, maxFileSizeBytes) {
+    const start = Date.now();
+    const issues = [];
+    const storeRegexes = (0, file_utils_1.compile_regexes)(config.mutableStoreRegexes);
+    const allowIfFileContains = (0, file_utils_1.compile_regexes)(config.allowIfFileContainsRegexes);
+    const testFileRegexes = config.testFileRegexes.map(r => new RegExp(r, 'i'));
+    const allowIfAnyTestContains = (0, file_utils_1.compile_regexes)(config.allowIfAnyTestContainsRegexes);
+    const testTexts = [];
+    for (const file of ctx.files) {
+        if (!testFileRegexes.some(r => r.test(file.relativePath))) {
+            continue;
+        }
+        const text = (0, file_utils_1.maybe_read_text)(file, maxFileSizeBytes);
+        if (text) {
+            testTexts.push(text);
+        }
+    }
+    const anyTestHasResetHook = testTexts.some(t => allowIfAnyTestContains.some(r => r.test(t)));
+    for (const file of ctx.files) {
+        if (!is_probably_source_file(file.relativePath)) {
+            continue;
+        }
+        const text = (0, file_utils_1.maybe_read_text)(file, maxFileSizeBytes);
+        if (!text) {
+            continue;
+        }
+        const lines = text.split('\n');
+        // scan first ~80 lines for module-scope mutable stores
+        const scanLines = lines.slice(0, Math.min(80, lines.length));
+        for (let i = 0; i < scanLines.length; i++) {
+            const line = scanLines[i] || '';
+            if (!storeRegexes.some(r => r.test(line))) {
+                continue;
+            }
+            const allowed = allowIfFileContains.some(r => r.test(text)) || anyTestHasResetHook;
+            if (allowed) {
+                continue;
+            }
+            issues.push({
+                message: 'mutable module-scope store detected without reset strategy',
+                filePath: file.relativePath,
+                line: i + 1,
+                excerpt: line.trim(),
+                hint: 'export a reset hook for tests or reset state in beforeEach()'
+            });
+            if (issues.length >= 25) {
+                break;
+            }
+        }
+        if (issues.length >= 25) {
+            break;
+        }
+    }
+    const durationMs = Date.now() - start;
+    const status = issues.length > 0 ? 'fail' : 'pass';
+    return {
+        id: 'test-isolation',
+        title: 'Tests are isolated (reset mutable state)',
+        status,
+        durationMs,
+        issues,
+        stats: {
+            issues: issues.length,
+            testFiles: testTexts.length
+        }
+    };
+}

package/dist/src/quality-gates/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parse_gitignore_dirs = exports.list_project_files = exports.registerGate = exports.loadProjectGateRegistrations = exports.getRegisteredGates = exports.getRegisteredGateKeys = exports.run_quality_gates = exports.DEFAULT_QUALITY_GATES_CONFIG = exports.load_quality_gates_config = void 0;
+var config_loader_1 = require("./config-loader");
+Object.defineProperty(exports, "load_quality_gates_config", { enumerable: true, get: function () { return config_loader_1.load_quality_gates_config; } });
+var default_config_1 = require("./default-config");
+Object.defineProperty(exports, "DEFAULT_QUALITY_GATES_CONFIG", { enumerable: true, get: function () { return default_config_1.DEFAULT_QUALITY_GATES_CONFIG; } });
+var gate_runner_1 = require("./gate-runner");
+Object.defineProperty(exports, "run_quality_gates", { enumerable: true, get: function () { return gate_runner_1.run_quality_gates; } });
+var registry_1 = require("./registry");
+Object.defineProperty(exports, "getRegisteredGateKeys", { enumerable: true, get: function () { return registry_1.getRegisteredGateKeys; } });
+Object.defineProperty(exports, "getRegisteredGates", { enumerable: true, get: function () { return registry_1.getRegisteredGates; } });
+Object.defineProperty(exports, "loadProjectGateRegistrations", { enumerable: true, get: function () { return registry_1.loadProjectGateRegistrations; } });
+Object.defineProperty(exports, "registerGate", { enumerable: true, get: function () { return registry_1.registerGate; } });
+var file_utils_1 = require("./file-utils");
+Object.defineProperty(exports, "list_project_files", { enumerable: true, get: function () { return file_utils_1.list_project_files; } });
+Object.defineProperty(exports, "parse_gitignore_dirs", { enumerable: true, get: function () { return file_utils_1.parse_gitignore_dirs; } });

package/dist/src/quality-gates/registry.js

@@ -0,0 +1,205 @@
+"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.SELF_IMPROVEMENT_GATE_KEYS = void 0;
+exports.registerGate = registerGate;
+exports.resetProjectGates = resetProjectGates;
+exports.getRegisteredGates = getRegisteredGates;
+exports.getRegisteredGateKeys = getRegisteredGateKeys;
+exports.loadProjectGateRegistrations = loadProjectGateRegistrations;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const default_config_1 = require("./default-config");
+const accessibility_1 = require("./gates/accessibility");
+const duplicate_blocks_1 = require("./gates/duplicate-blocks");
+const hardcoded_config_1 = require("./gates/hardcoded-config");
+const readme_claims_1 = require("./gates/readme-claims");
+const runtime_checks_1 = require("./gates/runtime-checks");
+const scaffold_defaults_1 = require("./gates/scaffold-defaults");
+const test_coverage_1 = require("./gates/test-coverage");
+const test_file_protection_1 = require("./gates/test-file-protection");
+const test_isolation_1 = require("./gates/test-isolation");
+const registry = new Map();
+const builtInKeys = new Set();
+const projectKeys = new Set();
+function registerBuiltInGate(gate) {
+    registry.set(gate.key, gate);
+    builtInKeys.add(gate.key);
+}
+function registerGate(gate) {
+    registry.set(gate.key, gate);
+    projectKeys.add(gate.key);
+}
+function resetProjectGates() {
+    for (const key of projectKeys) {
+        if (!builtInKeys.has(key)) {
+            registry.delete(key);
+        }
+    }
+    projectKeys.clear();
+}
+function getRegisteredGates() {
+    return Array.from(registry.values());
+}
+function getRegisteredGateKeys() {
+    return getRegisteredGates().map(gate => gate.key);
+}
+function resolveProjectGateModule(projectRoot) {
+    const candidates = [
+        path.join(projectRoot, '.swarm', 'gates', 'index.js'),
+        path.join(projectRoot, '.swarm', 'gates', 'index.cjs'),
+    ];
+    for (const candidate of candidates) {
+        if (fs.existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+function registerProjectExports(entry) {
+    if (typeof entry.registerGates === 'function') {
+        entry.registerGates({ registerGate });
+        return;
+    }
+    if (Array.isArray(entry.gates)) {
+        for (const gate of entry.gates)
+            registerGate(gate);
+        return;
+    }
+    if (typeof entry.default === 'function') {
+        entry.default({ registerGate });
+        return;
+    }
+    if (Array.isArray(entry.default)) {
+        for (const gate of entry.default)
+            registerGate(gate);
+    }
+}
+function loadProjectGateRegistrations(projectRoot) {
+    resetProjectGates();
+    const entryPath = resolveProjectGateModule(projectRoot);
+    if (!entryPath)
+        return [];
+    delete require.cache[require.resolve(entryPath)];
+    const loaded = require(entryPath);
+    registerProjectExports(loaded);
+    return [entryPath];
+}
+/**
+ * Gate keys that are "self-improvement" gates — the orchestrator applies
+ * them to its OWN generated code to enforce quality on code it produced.
+ * When the orchestrator is running against a target repo (swarm bootstrap
+ * against an external codebase), these gates should NOT fire: the target
+ * has its own conventions and the gates misattribute target-repo features
+ * as agent defects. Phase 4a smoke4 evidence: the accessibility gate
+ * flagged sympy (computer-algebra library, no UI) and triggered replan
+ * churn that wasted cycles and polluted the diff-capture.
+ *
+ * Gates NOT in this set are "universal" — they enforce agent-behavior
+ * contracts that apply regardless of whose codebase is being modified:
+ *   - hardcodedConfig       agent must not add secrets / hardcoded config
+ *                           (the gate scopes to baselineFiles, so it only
+ *                           flags what the agent added, not pre-existing
+ *                           target state — safe in target mode)
+ *   - testFileProtection    agent must not modify pre-existing test files
+ *                           (SWE-bench evaluation integrity + general
+ *                           safety property; always fires)
+ *
+ * `run_quality_gates` consults this set via the `skippedGateKeys` param
+ * the orchestrator passes when `targetMode === true`.
+ */
+exports.SELF_IMPROVEMENT_GATE_KEYS = new Set([
+    'scaffoldDefaults',
+    'duplicateBlocks',
+    'readmeClaims',
+    'testIsolation',
+    'runtimeChecks',
+    'accessibility',
+    'testCoverage',
+]);
+registerBuiltInGate({
+    key: 'scaffoldDefaults',
+    title: 'Scaffold Defaults',
+    defaultConfig: default_config_1.DEFAULT_QUALITY_GATES_CONFIG.gates.scaffoldDefaults,
+    run: (ctx, config, maxFileSizeBytes) => (0, scaffold_defaults_1.run_scaffold_defaults_gate)(ctx, config, maxFileSizeBytes),
+});
+registerBuiltInGate({
+    key: 'duplicateBlocks',
+    title: 'Duplicate Blocks',
+    defaultConfig: default_config_1.DEFAULT_QUALITY_GATES_CONFIG.gates.duplicateBlocks,
+    run: (ctx, config, maxFileSizeBytes) => (0, duplicate_blocks_1.run_duplicate_blocks_gate)(ctx, config, maxFileSizeBytes),
+});
+registerBuiltInGate({
+    key: 'hardcodedConfig',
+    title: 'Hardcoded Config',
+    defaultConfig: default_config_1.DEFAULT_QUALITY_GATES_CONFIG.gates.hardcodedConfig,
+    run: (ctx, config, maxFileSizeBytes) => (0, hardcoded_config_1.run_hardcoded_config_gate)(ctx, config, maxFileSizeBytes),
+});
+registerBuiltInGate({
+    key: 'readmeClaims',
+    title: 'README Claims',
+    defaultConfig: default_config_1.DEFAULT_QUALITY_GATES_CONFIG.gates.readmeClaims,
+    run: (ctx, config, maxFileSizeBytes) => (0, readme_claims_1.run_readme_claims_gate)(ctx, config, maxFileSizeBytes),
+});
+registerBuiltInGate({
+    key: 'testIsolation',
+    title: 'Test Isolation',
+    defaultConfig: default_config_1.DEFAULT_QUALITY_GATES_CONFIG.gates.testIsolation,
+    run: (ctx, config, maxFileSizeBytes) => (0, test_isolation_1.run_test_isolation_gate)(ctx, config, maxFileSizeBytes),
+});
+registerBuiltInGate({
+    key: 'runtimeChecks',
+    title: 'Runtime Checks',
+    defaultConfig: default_config_1.DEFAULT_QUALITY_GATES_CONFIG.gates.runtimeChecks,
+    run: (ctx, config) => (0, runtime_checks_1.run_runtime_checks_gate)(ctx.projectRoot, config, ctx.baseCommit),
+});
+registerBuiltInGate({
+    key: 'accessibility',
+    title: 'Accessibility',
+    defaultConfig: default_config_1.DEFAULT_QUALITY_GATES_CONFIG.gates.accessibility,
+    run: (ctx, config, maxFileSizeBytes) => (0, accessibility_1.run_accessibility_gate)(ctx, config, maxFileSizeBytes),
+});
+registerBuiltInGate({
+    key: 'testCoverage',
+    title: 'Test Coverage',
+    defaultConfig: default_config_1.DEFAULT_QUALITY_GATES_CONFIG.gates.testCoverage,
+    run: (ctx, config, maxFileSizeBytes) => (0, test_coverage_1.run_test_coverage_gate)(ctx, config, maxFileSizeBytes),
+});
+registerBuiltInGate({
+    key: 'testFileProtection',
+    title: 'Test File Protection',
+    defaultConfig: default_config_1.DEFAULT_QUALITY_GATES_CONFIG.gates.testFileProtection,
+    run: (ctx, config) => (0, test_file_protection_1.run_test_file_protection_gate)(ctx.projectRoot, config, ctx.baseCommit),
+});

package/dist/src/quality-gates/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });