swarm-orchestrator 7.0.0-alpha.0

package/dist/src/external-tool-manager.js

@@ -0,0 +1,184 @@
+"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.ExternalToolManager = void 0;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const logger_1 = require("./logger");
+const logger = (0, logger_1.getLogger)('external-tool-manager');
+/**
+ * External Tool Manager - handles external CLI tool execution with safety gating
+ * All external commands require explicit user confirmation via enableExternal flag
+ */
+class ExternalToolManager {
+    config;
+    executionLog = [];
+    toolAvailability;
+    constructor(config) {
+        this.config = config;
+    }
+    /**
+     * Detect which external tools are available
+     */
+    async detectAvailableTools() {
+        if (this.toolAvailability) {
+            return this.toolAvailability;
+        }
+        const availability = {
+            gh: await this.isToolAvailable('gh'),
+            vercel: await this.isToolAvailable('vercel'),
+            netlify: await this.isToolAvailable('netlify')
+        };
+        this.toolAvailability = availability;
+        return availability;
+    }
+    /**
+     * Check if a specific tool is available
+     */
+    async isToolAvailable(toolName) {
+        return new Promise((resolve) => {
+            const proc = (0, child_process_1.spawn)('which', [toolName]);
+            proc.on('close', (code) => {
+                resolve(code === 0);
+            });
+        });
+    }
+    /**
+     * Execute external command with safety gating
+     */
+    async executeCommand(command, args, options = {}) {
+        const execution = {
+            command,
+            args: this.sanitizeArgs(args), // Remove any potential secrets
+            workingDir: options.workingDir || process.cwd(),
+            timestamp: new Date().toISOString()
+        };
+        // Check tool availability if required
+        if (options.requireTool) {
+            const tools = await this.detectAvailableTools();
+            if (!tools[options.requireTool]) {
+                execution.exitCode = -1;
+                execution.error = `Tool '${options.requireTool}' not available`;
+                this.logExecution(execution);
+                return execution;
+            }
+        }
+        // Dry run mode: log but don't execute
+        if (this.config.dryRun) {
+            logger.info(`[DRY RUN] Would execute: ${command} ${args.join(' ')}`);
+            logger.info(`  Working dir: ${execution.workingDir}`);
+            execution.exitCode = 0;
+            execution.output = '[DRY RUN - not executed]';
+            this.logExecution(execution);
+            return execution;
+        }
+        // Safety gate: require explicit external permission
+        if (!this.config.enableExternal) {
+            execution.exitCode = -1;
+            execution.error = 'External tool execution disabled. Use --enable-external flag.';
+            this.logExecution(execution);
+            return execution;
+        }
+        // Execute command
+        const startTime = Date.now();
+        return new Promise((resolve) => {
+            const proc = (0, child_process_1.spawn)(command, args, {
+                cwd: execution.workingDir,
+                stdio: ['pipe', 'pipe', 'pipe']
+            });
+            let stdout = '';
+            let stderr = '';
+            proc.stdout.on('data', (data) => {
+                stdout += data.toString();
+            });
+            proc.stderr.on('data', (data) => {
+                stderr += data.toString();
+            });
+            proc.on('close', (code) => {
+                execution.exitCode = code || 0;
+                execution.output = stdout;
+                if (stderr)
+                    execution.error = stderr;
+                execution.duration = Date.now() - startTime;
+                this.logExecution(execution);
+                resolve(execution);
+            });
+            proc.on('error', (err) => {
+                execution.exitCode = -1;
+                execution.error = err.message;
+                execution.duration = Date.now() - startTime;
+                this.logExecution(execution);
+                resolve(execution);
+            });
+        });
+    }
+    /**
+     * Sanitize command arguments to remove secrets
+     */
+    sanitizeArgs(args) {
+        return args.map(arg => {
+            // Hide tokens and keys
+            if (arg.includes('token=') || arg.includes('key=') || arg.includes('secret=')) {
+                const parts = arg.split('=');
+                return `${parts[0]}=[REDACTED]`;
+            }
+            return arg;
+        });
+    }
+    /**
+     * Log command execution
+     */
+    logExecution(execution) {
+        this.executionLog.push(execution);
+        // Write to log file if specified
+        if (this.config.logFile) {
+            const logDir = path.dirname(this.config.logFile);
+            if (!fs.existsSync(logDir)) {
+                fs.mkdirSync(logDir, { recursive: true });
+            }
+            const logEntry = JSON.stringify(execution, null, 2) + '\n';
+            fs.appendFileSync(this.config.logFile, logEntry);
+        }
+    }
+    /**
+     * Get execution log
+     */
+    getExecutionLog() {
+        return [...this.executionLog];
+    }
+}
+exports.ExternalToolManager = ExternalToolManager;
+exports.default = ExternalToolManager;

package/dist/src/gate-prompt-builder.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classifyStep = classifyStep;
+exports.buildGateClauses = buildGateClauses;
+exports.getGateRequirements = getGateRequirements;
+exports.requiresTestStep = requiresTestStep;
+/** Agent names that indicate frontend-facing work. */
+const FRONTEND_AGENTS = new Set();
+/** Agent names that indicate test-writing work. */
+const TEST_AGENTS = new Set();
+/** Agent names that indicate documentation/review work. */
+const DOC_AGENTS = new Set(['reviewer']);
+/**
+ * Classify a step by its agent name to determine which gate requirements apply.
+ * @param agentName - The agent assigned to the step
+ * @returns The step category
+ */
+function classifyStep(agentName) {
+    if (TEST_AGENTS.has(agentName))
+        return 'test';
+    if (FRONTEND_AGENTS.has(agentName))
+        return 'frontend';
+    if (DOC_AGENTS.has(agentName))
+        return 'documentation';
+    return 'code-generation';
+}
+/**
+ * Build gate-aware prompt clauses from resolved quality gate configuration.
+ * Returns an array of clauses, each with its applicable step categories.
+ * Only produces clauses for gates that are enabled.
+ * @param config - Resolved quality gates configuration
+ * @returns Array of gate-derived prompt clauses
+ */
+function buildGateClauses(config) {
+    if (!config.enabled)
+        return [];
+    const clauses = [];
+    const gates = config.gates;
+    if (gates.scaffoldDefaults.enabled) {
+        clauses.push({
+            appliesTo: ['code-generation', 'test', 'frontend', 'documentation', 'all'],
+            text: 'Remove all TODO comments, placeholder text, and default scaffold values before completing.',
+        });
+    }
+    if (gates.duplicateBlocks.enabled) {
+        clauses.push({
+            appliesTo: ['code-generation', 'frontend'],
+            text: 'Avoid duplicating code blocks. Extract shared logic into utility functions.',
+        });
+    }
+    if (gates.hardcodedConfig.enabled) {
+        clauses.push({
+            appliesTo: ['code-generation', 'frontend'],
+            text: 'Use environment variables for configuration values. No hardcoded URLs, ports, credentials, or API keys.',
+        });
+    }
+    if (gates.testCoverage.enabled) {
+        clauses.push({
+            appliesTo: ['test'],
+            text: `Achieve thorough test coverage. Test every exported function and major code path.`,
+        });
+    }
+    if (gates.testIsolation.enabled) {
+        clauses.push({
+            appliesTo: ['test'],
+            text: 'Each test must be independently runnable. No shared mutable state between tests.',
+        });
+    }
+    if (gates.accessibility.enabled) {
+        clauses.push({
+            appliesTo: ['frontend'],
+            text: 'Include ARIA attributes, keyboard navigation, and semantic HTML.',
+        });
+    }
+    if (gates.readmeClaims.enabled) {
+        clauses.push({
+            appliesTo: ['documentation'],
+            text: 'README claims must match actual implemented functionality.',
+        });
+    }
+    if (gates.runtimeChecks.enabled) {
+        clauses.push({
+            appliesTo: ['code-generation', 'test', 'frontend', 'documentation', 'all'],
+            text: 'Code must build and pass all tests before completion.',
+        });
+    }
+    return clauses;
+}
+/**
+ * Get requirement lines to append to a step's prompt based on gate config.
+ * Filters clauses to those applicable to the step's category, then formats
+ * them as a bulleted list. Returns empty string if no clauses apply.
+ * @param config - Resolved quality gates configuration
+ * @param agentName - Agent assigned to the step (used for classification)
+ * @returns Formatted requirement text to append to the step prompt, or empty string
+ */
+function getGateRequirements(config, agentName) {
+    const clauses = buildGateClauses(config);
+    if (clauses.length === 0)
+        return '';
+    const category = classifyStep(agentName);
+    const applicable = clauses.filter(c => c.appliesTo.includes(category) || c.appliesTo.includes('all'));
+    if (applicable.length === 0)
+        return '';
+    const lines = applicable.map(c => `- ${c.text}`).join('\n');
+    return `\n\nQuality gate requirements:\n${lines}`;
+}
+/**
+ * Check whether the gate config indicates a need for an explicit test step.
+ * Returns true when testCoverage is enabled, which signals the planner
+ * should verify a worker test step exists in the plan.
+ * @param config - Resolved quality gates configuration
+ * @returns Whether a test step should be ensured
+ */
+function requiresTestStep(config) {
+    return config.enabled && config.gates.testCoverage.enabled;
+}

package/dist/src/gate-remediation.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildRemediationStep = buildRemediationStep;
+exports.runQualityGateRemediation = runQualityGateRemediation;
+const logger_1 = require("./logger");
+const quality_gates_1 = require("./quality-gates");
+const logger = (0, logger_1.getLogger)('gate-remediation');
+// ---------------------------------------------------------------------------
+// buildRemediationStep
+// ---------------------------------------------------------------------------
+/**
+ * Inspect a single gate result and, if it failed and auto-fix is enabled
+ * (and hasn't already been attempted), return a remediation step descriptor.
+ * Returns `null` when no action is needed.
+ */
+function buildRemediationStep(gateResult, configEnabled, triggeredFlag, triggeredFlags, agents, resolveAgent, taskDescription, warningMessage, afterStep, fallbackAgent) {
+    if (!gateResult || gateResult.status !== 'fail')
+        return null;
+    if (!configEnabled)
+        return null;
+    if (triggeredFlags[triggeredFlag])
+        return null;
+    const preferredAgent = resolveAgent(agents, 'integrator_finalizer')
+        ? 'integrator_finalizer'
+        : fallbackAgent;
+    logger.warn(warningMessage);
+    triggeredFlags[triggeredFlag] = true;
+    // Append specific findings so the remediation agent knows exactly what to fix
+    let taskWithFindings = taskDescription;
+    if (gateResult.issues && gateResult.issues.length > 0) {
+        const findings = gateResult.issues.map(issue => {
+            let finding = `- ${issue.message}`;
+            if (issue.filePath)
+                finding += ` (${issue.filePath})`;
+            if (issue.hint)
+                finding += ` -- hint: ${issue.hint}`;
+            return finding;
+        }).join('\n');
+        taskWithFindings += `\n\nSpecific findings from the gate:\n${findings}`;
+    }
+    return { agent: preferredAgent, task: taskWithFindings, afterStep };
+}
+// ---------------------------------------------------------------------------
+// runQualityGateRemediation
+// ---------------------------------------------------------------------------
+/**
+ * Run quality gates, check if auto-fix is possible, build remediation steps,
+ * consolidate them into a single step if multiple are needed, call
+ * `executeReplan`, re-run gates, and if still failing do a second attempt
+ * with specific findings.
+ *
+ * Returns whether the final gate run passed and the latest gate results.
+ */
+async function runQualityGateRemediation(params) {
+    const { workingDir, gatesConfig, gatesOut, baselineFiles, baseCommit, skippedReqIds, context, agents, options, resolveAgent, executeReplan, } = params;
+    // Initial quality-gate run
+    let gatesResult = await (0, quality_gates_1.run_quality_gates)(workingDir, gatesConfig, gatesOut, baselineFiles, baseCommit, skippedReqIds);
+    context.finalGateResults = gatesResult.results;
+    if (!gatesResult.passed && gatesConfig.failOnIssues) {
+        const failedIds = new Set(gatesResult.results.filter(r => r.status === 'fail').map(r => r.id));
+        let remediationAttempted = false;
+        const triggeredFlags = context.qualityGatesTriggered || {};
+        const canAutoFix = !!context.qualityGatesTriggered && ((failedIds.has('duplicate-blocks') && gatesConfig.autoAddRefactorStepOnDuplicateBlocks && !triggeredFlags.duplicateRefactorAdded) ||
+            (failedIds.has('readme-claims') && gatesConfig.autoAddReadmeTruthStepOnReadmeClaims && !triggeredFlags.readmeTruthAdded) ||
+            (failedIds.has('scaffold-defaults') && gatesConfig.autoAddScaffoldFixStepOnScaffoldDefaults && !triggeredFlags.scaffoldFixAdded) ||
+            (failedIds.has('hardcoded-config') && gatesConfig.autoAddConfigFixStepOnHardcodedConfig && !triggeredFlags.configFixAdded) ||
+            (failedIds.has('accessibility') && gatesConfig.autoAddAccessibilityFixStepOnAccessibility && !triggeredFlags.accessibilityFixAdded) ||
+            (failedIds.has('test-coverage') && gatesConfig.autoAddTestCoverageStepOnTestCoverage && !triggeredFlags.testCoverageFixAdded));
+        if (canAutoFix) {
+            // Remediation steps should depend only on steps that actually completed.
+            // Using the max step number can create dependencies on failed/blocked steps,
+            // causing the remediation to wait forever then timeout.
+            const completedStepNumbers = context.results
+                .filter(r => r.status === 'completed')
+                .map(r => r.stepNumber);
+            const maxCompletedStep = completedStepNumbers.length > 0
+                ? Math.max(...completedStepNumbers)
+                : 0; // no dependency if nothing completed
+            const lastAgent = context.plan.steps[context.plan.steps.length - 1]?.agentName || 'integrator_finalizer';
+            const addSteps = [];
+            const dupStep = buildRemediationStep(gatesResult.results.find(r => r.id === 'duplicate-blocks'), gatesConfig.autoAddRefactorStepOnDuplicateBlocks, 'duplicateRefactorAdded', triggeredFlags, agents, resolveAgent, 'Quality gates flagged repeated code blocks. Extract shared utilities/hooks/middleware and refactor duplicates away. Use the gate report as the source of truth. Re-run tests and ensure quality gates pass.', '⚠️  Final quality gates: duplicate blocks detected; scheduling refactor', maxCompletedStep, lastAgent);
+            if (dupStep)
+                addSteps.push(dupStep);
+            const readmeStep = buildRemediationStep(gatesResult.results.find(r => r.id === 'readme-claims'), gatesConfig.autoAddReadmeTruthStepOnReadmeClaims, 'readmeTruthAdded', triggeredFlags, agents, resolveAgent, 'Quality gates flagged README claims that are not backed by code. Either implement the missing features or downgrade/remove the claims. Use the gate report as the source of truth. Re-run tests and ensure quality gates pass.', '⚠️  Final quality gates: README claims mismatch; scheduling truth step', maxCompletedStep, lastAgent);
+            if (readmeStep)
+                addSteps.push(readmeStep);
+            const scaffoldStep = buildRemediationStep(gatesResult.results.find(r => r.id === 'scaffold-defaults'), gatesConfig.autoAddScaffoldFixStepOnScaffoldDefaults, 'scaffoldFixAdded', triggeredFlags, agents, resolveAgent, 'Quality gates flagged scaffold defaults. Remove placeholder assets and generic scaffold README sections, and ensure HTML title/app metadata are meaningful. Use the gate report as the source of truth. Re-run tests and ensure quality gates pass.', '⚠️  Final quality gates: scaffold defaults detected; scheduling cleanup', maxCompletedStep, lastAgent);
+            if (scaffoldStep)
+                addSteps.push(scaffoldStep);
+            const configStep = buildRemediationStep(gatesResult.results.find(r => r.id === 'hardcoded-config'), gatesConfig.autoAddConfigFixStepOnHardcodedConfig, 'configFixAdded', triggeredFlags, agents, resolveAgent, 'Quality gates flagged hardcoded config values. Move API base URLs, ports, retry counts, timeouts, and environment-specific values into env/typed config. For Vite proxy targets, prefer import.meta.env with a safe default. Use the gate report as the source of truth. Re-run tests and ensure quality gates pass.', '⚠️  Final quality gates: hardcoded config detected; scheduling cleanup', maxCompletedStep, lastAgent);
+            if (configStep)
+                addSteps.push(configStep);
+            const a11yStep = buildRemediationStep(gatesResult.results.find(r => r.id === 'accessibility'), gatesConfig.autoAddAccessibilityFixStepOnAccessibility, 'accessibilityFixAdded', triggeredFlags, agents, resolveAgent, 'Quality gates flagged accessibility issues. Fix all items from the gate report: skip-to-content link, heading hierarchy, aria-labels, focus-visible styles, meta description + theme-color tags, responsive CSS (viewport meta, media queries or relative units), CSS custom properties on :root with prefers-color-scheme:dark override, semantic HTML landmarks (main, nav, header), img alt attributes. Use the gate report as the source of truth. Re-run tests and ensure quality gates pass.', '⚠️  Final quality gates: accessibility issues detected; scheduling fix', maxCompletedStep, lastAgent);
+            if (a11yStep)
+                addSteps.push(a11yStep);
+            const testCovStep = buildRemediationStep(gatesResult.results.find(r => r.id === 'test-coverage'), gatesConfig.autoAddTestCoverageStepOnTestCoverage, 'testCoverageFixAdded', triggeredFlags, agents, resolveAgent, 'Quality gates flagged missing test coverage. Add tests for uncovered source files, ensure each test file contains real assertions, and add component-level tests for React projects. Use the gate report as the source of truth. Re-run tests and ensure quality gates pass.', '⚠️  Final quality gates: test coverage gaps detected; scheduling fix', maxCompletedStep, lastAgent);
+            if (testCovStep)
+                addSteps.push(testCovStep);
+            // Consolidate multiple gate failures into a single remediation step
+            // to avoid burning one premium request per gate failure.
+            if (addSteps.length > 1) {
+                const combinedTask = addSteps.map(s => s.task).join('\n\nALSO: ');
+                const singleStep = {
+                    agent: addSteps[0].agent,
+                    task: combinedTask,
+                };
+                if (addSteps[0].afterStep !== undefined) {
+                    singleStep.afterStep = addSteps[0].afterStep;
+                }
+                addSteps.length = 0;
+                addSteps.push(singleStep);
+                logger.warn(`⚠️  Final quality gates failed (${failedIds.size} gates); scheduling single consolidated remediation step...`);
+            }
+            else if (addSteps.length === 1) {
+                logger.warn('⚠️  Final quality gates failed; attempting one remediation pass...');
+            }
+            if (addSteps.length > 0) {
+                remediationAttempted = true;
+                await executeReplan(context, { retrySteps: [], addSteps }, agents, options);
+                gatesResult = await (0, quality_gates_1.run_quality_gates)(workingDir, gatesConfig, gatesOut, baselineFiles, baseCommit, skippedReqIds);
+                context.finalGateResults = gatesResult.results;
+                // Second remediation attempt if gates still fail after first fix
+                if (!gatesResult.passed && gatesConfig.failOnIssues) {
+                    const stillFailed = gatesResult.results.filter(r => r.status === 'fail');
+                    if (stillFailed.length > 0) {
+                        const findings = stillFailed.flatMap(gate => gate.issues.map(issue => {
+                            let desc = `[${gate.id}] ${issue.message}`;
+                            if (issue.filePath)
+                                desc += ` (${issue.filePath})`;
+                            if (issue.hint)
+                                desc += ` -- hint: ${issue.hint}`;
+                            return desc;
+                        })).join('\n');
+                        const retryTask = [
+                            'The previous remediation attempt did not fully resolve the quality gate failures.',
+                            'The following issues remain. Fix each one specifically:',
+                            '',
+                            findings,
+                            '',
+                            'Verify your fixes by checking that the specific issues listed above are resolved.',
+                            'Run tests to ensure nothing is broken.',
+                        ].join('\n');
+                        const retryAgent = resolveAgent(agents, 'integrator_finalizer')
+                            ? 'integrator_finalizer'
+                            : lastAgent;
+                        const retryMaxStep = Math.max(...context.plan.steps.map(s => s.stepNumber));
+                        logger.warn('⚠️  First remediation did not resolve all gate failures. Running second attempt with specific findings...');
+                        await executeReplan(context, {
+                            retrySteps: [],
+                            addSteps: [{ agent: retryAgent, task: retryTask, afterStep: retryMaxStep }],
+                        }, agents, options);
+                        gatesResult = await (0, quality_gates_1.run_quality_gates)(workingDir, gatesConfig, gatesOut, baselineFiles, baseCommit, skippedReqIds);
+                        context.finalGateResults = gatesResult.results;
+                    }
+                }
+            }
+        }
+        if (!gatesResult.passed) {
+            if (remediationAttempted) {
+                // Remediation was attempted but couldn't fully resolve all issues.
+                // Downgrade to a warning so callers can decide how to handle.
+                const remaining = gatesResult.results
+                    .filter(r => r.status === 'fail')
+                    .map(r => `${r.id} (${r.issues.length} issues)`);
+                logger.warn(`⚠️  Quality gates still have issues after remediation: ${remaining.join(', ')}`);
+            }
+            else {
+                logger.error('❌ Quality gates failed. See report in:', gatesOut);
+            }
+        }
+    }
+    return { passed: gatesResult.passed, results: gatesResult.results };
+}

package/dist/src/github-issues-ingester.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitHubIssuesIngester = void 0;
+const child_process_1 = require("child_process");
+const logger_1 = require("./logger");
+const logger = (0, logger_1.getLogger)('github-issues-ingester');
+/**
+ * GitHub Issues Ingester - fetch open issues via gh CLI
+ * Only used if gh CLI is available and repo has .git directory
+ */
+class GitHubIssuesIngester {
+    /**
+     * Check if gh CLI is available
+     */
+    async isGhCliAvailable() {
+        return new Promise((resolve) => {
+            const proc = (0, child_process_1.spawn)('which', ['gh']);
+            proc.on('close', (code) => {
+                resolve(code === 0);
+            });
+        });
+    }
+    /**
+     * Fetch open issues for a repository
+     */
+    async fetchIssues(repoPath) {
+        const ghAvailable = await this.isGhCliAvailable();
+        if (!ghAvailable) {
+            logger.warn('gh CLI not available, skipping issue ingestion');
+            return [];
+        }
+        return new Promise((resolve, _reject) => {
+            const proc = (0, child_process_1.spawn)('gh', ['issue', 'list', '--json', 'number,title,url,labels,createdAt', '--limit', '50'], {
+                cwd: repoPath,
+                stdio: ['pipe', 'pipe', 'pipe']
+            });
+            let stdout = '';
+            let stderr = '';
+            proc.stdout.on('data', (data) => {
+                stdout += data.toString();
+            });
+            proc.stderr.on('data', (data) => {
+                stderr += data.toString();
+            });
+            proc.on('close', (code) => {
+                if (code !== 0) {
+                    logger.warn(`gh issue list failed: ${stderr}`);
+                    resolve([]);
+                    return;
+                }
+                try {
+                    const rawIssues = JSON.parse(stdout);
+                    const issues = rawIssues.map((issue) => ({
+                        number: issue.number,
+                        title: issue.title,
+                        url: issue.url,
+                        labels: issue.labels?.map((l) => typeof l === 'string' ? l : l.name || '') || [],
+                        repoName: this.extractRepoName(issue.url),
+                        createdAt: issue.createdAt
+                    }));
+                    resolve(issues);
+                }
+                catch (error) {
+                    logger.warn(`Failed to parse gh issue output: ${error}`);
+                    resolve([]);
+                }
+            });
+        });
+    }
+    /**
+     * Extract repo name from GitHub URL
+     */
+    extractRepoName(url) {
+        const match = url.match(/github\.com\/([^/]+\/[^/]+)/);
+        return match ? match[1] : 'unknown';
+    }
+    /**
+     * Link issues to plan context based on keywords
+     */
+    linkIssuesToTasks(issues, goal) {
+        // Simple keyword matching - find issues relevant to goal
+        const goalKeywords = goal.toLowerCase().split(/\s+/).filter(w => w.length > 3);
+        return issues.filter(issue => {
+            const searchText = `${issue.title} ${issue.labels.join(' ')}`.toLowerCase();
+            return goalKeywords.some(keyword => searchText.includes(keyword));
+        });
+    }
+    /**
+     * Close an issue with a comment
+     */
+    async closeIssue(issueNumber, comment, repoPath) {
+        const ghAvailable = await this.isGhCliAvailable();
+        if (!ghAvailable) {
+            return { success: false, error: 'gh CLI not available' };
+        }
+        return new Promise((resolve) => {
+            // Add comment first
+            const commentProc = (0, child_process_1.spawn)('gh', ['issue', 'comment', issueNumber.toString(), '--body', comment], {
+                cwd: repoPath,
+                stdio: ['pipe', 'pipe', 'pipe']
+            });
+            let commentError = '';
+            commentProc.stderr.on('data', (data) => {
+                commentError += data.toString();
+            });
+            commentProc.on('close', (commentCode) => {
+                if (commentCode !== 0) {
+                    resolve({ success: false, error: `Failed to add comment: ${commentError}` });
+                    return;
+                }
+                // Then close the issue
+                const closeProc = (0, child_process_1.spawn)('gh', ['issue', 'close', issueNumber.toString()], {
+                    cwd: repoPath,
+                    stdio: ['pipe', 'pipe', 'pipe']
+                });
+                let closeError = '';
+                closeProc.stderr.on('data', (data) => {
+                    closeError += data.toString();
+                });
+                closeProc.on('close', (closeCode) => {
+                    if (closeCode !== 0) {
+                        resolve({ success: false, error: `Failed to close issue: ${closeError}` });
+                        return;
+                    }
+                    resolve({ success: true });
+                });
+            });
+        });
+    }
+    /**
+     * Close multiple issues resolved by a step
+     */
+    async closeResolvedIssues(issueNumbers, stepNumber, agentName, repoPath) {
+        const comment = `✅ Resolved by swarm orchestrator - Step ${stepNumber} (${agentName})`;
+        let closed = 0;
+        let failed = 0;
+        for (const issueNumber of issueNumbers) {
+            const result = await this.closeIssue(issueNumber, comment, repoPath);
+            if (result.success) {
+                closed++;
+                logger.info(`  ✓ Closed issue #${issueNumber}`);
+            }
+            else {
+                failed++;
+                logger.warn(`  ✗ Failed to close issue #${issueNumber}: ${result.error}`);
+            }
+        }
+        return { closed, failed };
+    }
+}
+exports.GitHubIssuesIngester = GitHubIssuesIngester;
+exports.default = GitHubIssuesIngester;