@ai-sdlc/orchestrator 0.1.0

package/dist/cli/formatters/table.js

@@ -0,0 +1,184 @@
+/**
+ * Table output formatter — human-readable tabular output.
+ */
+export function formatTable(data) {
+    const type = data.type;
+    const lines = [];
+    switch (type) {
+        case 'run': {
+            lines.push('Pipeline Run Result');
+            lines.push('─'.repeat(40));
+            lines.push(`Issue:      #${data.issueNumber}`);
+            lines.push(`PR URL:     ${data.prUrl}`);
+            lines.push(`Files:      ${data.filesChanged}`);
+            lines.push(`Promotion:  ${data.promotionEligible ? 'eligible' : 'not eligible'}`);
+            break;
+        }
+        case 'status': {
+            lines.push(`Pipeline: ${data.pipeline}`);
+            lines.push('─'.repeat(50));
+            const runs = data.recentRuns;
+            if (runs.length === 0) {
+                lines.push('No recent runs.');
+            }
+            else {
+                lines.push('Run ID'.padEnd(30) + 'Issue'.padEnd(10) + 'Status'.padEnd(12) + 'Started');
+                lines.push('─'.repeat(70));
+                for (const run of runs) {
+                    lines.push(String(run.runId ?? '').padEnd(30) +
+                        String(run.issueNumber ? `#${run.issueNumber}` : '-').padEnd(10) +
+                        String(run.status ?? '').padEnd(12) +
+                        String(run.startedAt ?? '-'));
+                }
+            }
+            break;
+        }
+        case 'health': {
+            lines.push('Health Check');
+            lines.push('─'.repeat(40));
+            lines.push(`Config:      ${data.configValid ? 'valid' : 'INVALID'}`);
+            lines.push(`State Store: ${data.stateStoreConnected ? 'connected' : 'not configured'}`);
+            const errors = data.errors;
+            if (errors.length > 0) {
+                lines.push('');
+                lines.push('Errors:');
+                for (const e of errors) {
+                    lines.push(`  - ${e}`);
+                }
+            }
+            break;
+        }
+        case 'agents': {
+            lines.push('Agent Roster');
+            lines.push('─'.repeat(50));
+            const agents = data.agents;
+            if (agents.length === 0) {
+                lines.push('No agents registered.');
+            }
+            else {
+                lines.push('Agent'.padEnd(20) +
+                    'Level'.padEnd(7) +
+                    'Tasks'.padEnd(7) +
+                    'Success'.padEnd(9) +
+                    'Last Task');
+                lines.push('─'.repeat(70));
+                for (const agent of agents) {
+                    const total = agent.totalTasks;
+                    const success = agent.successCount;
+                    const pct = total > 0 ? `${Math.round((success / total) * 100)}%` : '-';
+                    const lastTask = agent.lastTaskAt ? agent.lastTaskAt.split('T')[0] : '-';
+                    lines.push(String(agent.agentName ?? '').padEnd(20) +
+                        String(agent.currentLevel ?? 0).padEnd(7) +
+                        String(total).padEnd(7) +
+                        pct.padEnd(9) +
+                        lastTask);
+                }
+            }
+            break;
+        }
+        case 'routing': {
+            const duration = data.duration ?? '30d';
+            lines.push(`Routing Distribution (last ${duration})`);
+            lines.push('─'.repeat(50));
+            const history = data.history;
+            // Group by strategy
+            const groups = new Map();
+            for (const entry of history) {
+                const strategy = entry.routingStrategy;
+                groups.set(strategy, (groups.get(strategy) ?? 0) + 1);
+            }
+            if (groups.size === 0) {
+                lines.push('No routing decisions recorded.');
+            }
+            else {
+                lines.push('Strategy'.padEnd(20) + 'Count'.padEnd(8) + 'Percentage');
+                lines.push('─'.repeat(50));
+                const total = history.length;
+                const sorted = [...groups.entries()].sort((a, b) => b[1] - a[1]);
+                for (const [strategy, count] of sorted) {
+                    const pct = `${Math.round((count / total) * 100)}%`;
+                    lines.push(strategy.padEnd(20) + String(count).padEnd(8) + pct);
+                }
+            }
+            break;
+        }
+        case 'complexity': {
+            const profile = data.profile;
+            const _context = data.context;
+            lines.push('Codebase Complexity Profile');
+            lines.push('─'.repeat(50));
+            lines.push(`Score: ${profile.score}/10 | Files: ${profile.filesCount} | Modules: ${profile.modulesCount} | Deps: ${profile.dependencyCount}`);
+            const patterns = profile.architecturalPatterns;
+            if (patterns && patterns.length > 0) {
+                lines.push('');
+                lines.push('Architectural Patterns');
+                for (const p of patterns.slice(0, 5)) {
+                    const pct = Math.round(p.confidence * 100);
+                    lines.push(`  ${String(p.name).padEnd(16)} ${pct}% — ${p.description}`);
+                }
+            }
+            const hotspots = profile.hotspots;
+            if (hotspots && hotspots.length > 0) {
+                lines.push('');
+                lines.push('Hotspots (top 5)');
+                for (const h of hotspots.slice(0, 5)) {
+                    const churnPct = Math.round(h.churnRate * 100);
+                    lines.push(`  ${String(h.filePath).padEnd(40)} churn: ${churnPct}%  complexity: ${h.complexity}`);
+                }
+            }
+            const conventions = profile.conventions;
+            if (conventions && conventions.length > 0) {
+                lines.push('');
+                lines.push('Conventions');
+                for (const c of conventions) {
+                    lines.push(`  ${c.category}:  ${c.pattern}`);
+                }
+            }
+            break;
+        }
+        case 'cost': {
+            const summary = data.summary;
+            const budget = data.budget;
+            const period = data.period ?? 'all-time';
+            lines.push(`Cost Summary (${period})`);
+            lines.push('─'.repeat(50));
+            lines.push(`Total Cost:     $${summary.totalCostUsd.toFixed(2)}`);
+            lines.push(`Total Tokens:   ${summary.totalTokens}`);
+            lines.push(`Runs:           ${summary.entryCount}`);
+            lines.push(`Avg Cost/Run:   $${summary.avgCostPerRun.toFixed(4)}`);
+            lines.push('');
+            lines.push('Budget Status');
+            lines.push('─'.repeat(50));
+            lines.push(`Budget:         $${budget.budgetUsd}`);
+            lines.push(`Spent:          $${budget.spentUsd.toFixed(2)}`);
+            lines.push(`Remaining:      $${budget.remainingUsd.toFixed(2)}`);
+            lines.push(`Utilization:    ${budget.utilizationPercent.toFixed(1)}%`);
+            if (budget.overBudget) {
+                lines.push('  ** OVER BUDGET **');
+            }
+            const costByAgent = summary.costByAgent;
+            if (costByAgent && Object.keys(costByAgent).length > 0) {
+                lines.push('');
+                lines.push('Cost by Agent');
+                lines.push('─'.repeat(50));
+                lines.push('Agent'.padEnd(20) + 'Cost');
+                for (const [agent, cost] of Object.entries(costByAgent)) {
+                    lines.push(agent.padEnd(20) + `$${cost.toFixed(4)}`);
+                }
+            }
+            if (data.agent && data.filteredCost !== undefined) {
+                lines.push('');
+                lines.push(`Filtered (${data.agent}): $${data.filteredCost.toFixed(4)}`);
+            }
+            break;
+        }
+        default: {
+            // Generic key-value output
+            for (const [key, value] of Object.entries(data)) {
+                lines.push(`${key}: ${JSON.stringify(value)}`);
+            }
+        }
+    }
+    return lines.join('\n');
+}
+//# sourceMappingURL=table.js.map

package/dist/cli/index.d.ts

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+/**
+ * AI-SDLC CLI — entry point for the Commander-based CLI.
+ */
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/index.js

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+/**
+ * AI-SDLC CLI — entry point for the Commander-based CLI.
+ */
+import { Command } from 'commander';
+import { initCommand } from './commands/init.js';
+import { runCommand } from './commands/run.js';
+import { startCommand } from './commands/start.js';
+import { statusCommand } from './commands/status.js';
+import { healthCommand } from './commands/health.js';
+import { agentsCommand } from './commands/agents.js';
+import { routingCommand } from './commands/routing.js';
+import { complexityCommand } from './commands/complexity.js';
+import { costCommand } from './commands/cost.js';
+import { dashboardCommand } from './commands/dashboard.js';
+const program = new Command();
+program
+    .name('ai-sdlc')
+    .description('AI-SDLC Orchestrator — drive issues through the SDLC with AI agents')
+    .version('0.1.0')
+    .option('-c, --config <dir>', 'Config directory path', '.ai-sdlc')
+    .option('-f, --format <type>', 'Output format: table, json, minimal', 'table')
+    .option('-v, --verbose', 'Enable verbose output');
+program.addCommand(initCommand);
+program.addCommand(runCommand);
+program.addCommand(startCommand);
+program.addCommand(statusCommand);
+program.addCommand(healthCommand);
+program.addCommand(agentsCommand);
+program.addCommand(routingCommand);
+program.addCommand(complexityCommand);
+program.addCommand(costCommand);
+program.addCommand(dashboardCommand);
+program.parse();
+//# sourceMappingURL=index.js.map

package/dist/compliance-extended.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Extended compliance integration — covers individual framework checking,
+ * control IDs, framework mappings, and all 6 regulatory frameworks.
+ */
+import { type RegulatoryFramework, type ControlMapping, type ComplianceCoverageReport } from '@ai-sdlc/reference';
+/**
+ * Check compliance against a single regulatory framework.
+ */
+export declare function checkFrameworkCompliance(framework: RegulatoryFramework, implementedControls: ReadonlySet<string>): ComplianceCoverageReport;
+/**
+ * Get all control IDs defined in the AI-SDLC control catalog.
+ */
+export declare function getControlCatalog(): Set<string>;
+/**
+ * Get the control mappings for a specific regulatory framework.
+ */
+export declare function getFrameworkMappings(framework: RegulatoryFramework): readonly ControlMapping[];
+/**
+ * List all supported regulatory frameworks.
+ */
+export declare function listSupportedFrameworks(): readonly RegulatoryFramework[];
+/**
+ * Detailed compliance report for a single framework.
+ */
+export interface DetailedFrameworkReport {
+    framework: RegulatoryFramework;
+    coveragePercent: number;
+    gaps: string[];
+    coveredControls: string[];
+}
+/**
+ * Generate a detailed compliance report for each of the 6 regulatory frameworks.
+ */
+export declare function generateDetailedComplianceReport(implementedControls: ReadonlySet<string>): DetailedFrameworkReport[];
+/**
+ * Get compliance gaps (missing controls) for a specific framework.
+ */
+export declare function getComplianceGaps(framework: RegulatoryFramework, implementedControls: ReadonlySet<string>): string[];
+export { checkCompliance, checkAllFrameworks, getAllControlIds, getMappingsForFramework, AI_SDLC_CONTROLS, EU_AI_ACT_MAPPINGS, NIST_AI_RMF_MAPPINGS, ISO_42001_MAPPINGS, ISO_12207_MAPPINGS, OWASP_ASI_MAPPINGS, CSA_ATF_MAPPINGS, REGULATORY_FRAMEWORKS, } from '@ai-sdlc/reference';
+export type { RegulatoryFramework, ComplianceControl, ControlMapping, ComplianceCoverageReport, } from '@ai-sdlc/reference';
+//# sourceMappingURL=compliance-extended.d.ts.map

package/dist/compliance-extended.js

@@ -0,0 +1,58 @@
+/**
+ * Extended compliance integration — covers individual framework checking,
+ * control IDs, framework mappings, and all 6 regulatory frameworks.
+ */
+import { checkCompliance, getAllControlIds, getMappingsForFramework, REGULATORY_FRAMEWORKS, } from '@ai-sdlc/reference';
+/**
+ * Check compliance against a single regulatory framework.
+ */
+export function checkFrameworkCompliance(framework, implementedControls) {
+    return checkCompliance(implementedControls, framework);
+}
+/**
+ * Get all control IDs defined in the AI-SDLC control catalog.
+ */
+export function getControlCatalog() {
+    return getAllControlIds();
+}
+/**
+ * Get the control mappings for a specific regulatory framework.
+ */
+export function getFrameworkMappings(framework) {
+    return getMappingsForFramework(framework);
+}
+/**
+ * List all supported regulatory frameworks.
+ */
+export function listSupportedFrameworks() {
+    return [...REGULATORY_FRAMEWORKS];
+}
+/**
+ * Generate a detailed compliance report for each of the 6 regulatory frameworks.
+ */
+export function generateDetailedComplianceReport(implementedControls) {
+    const frameworks = listSupportedFrameworks();
+    return frameworks.map((framework) => {
+        const report = checkCompliance(implementedControls, framework);
+        const mappings = getMappingsForFramework(framework);
+        const requiredControls = mappings.map((m) => m.controlId);
+        const covered = requiredControls.filter((c) => implementedControls.has(c));
+        const gaps = requiredControls.filter((c) => !implementedControls.has(c));
+        return {
+            framework,
+            coveragePercent: report.coveragePercent,
+            gaps,
+            coveredControls: covered,
+        };
+    });
+}
+/**
+ * Get compliance gaps (missing controls) for a specific framework.
+ */
+export function getComplianceGaps(framework, implementedControls) {
+    const mappings = getMappingsForFramework(framework);
+    return mappings.map((m) => m.controlId).filter((c) => !implementedControls.has(c));
+}
+// Direct re-exports (passthrough)
+export { checkCompliance, checkAllFrameworks, getAllControlIds, getMappingsForFramework, AI_SDLC_CONTROLS, EU_AI_ACT_MAPPINGS, NIST_AI_RMF_MAPPINGS, ISO_42001_MAPPINGS, ISO_12207_MAPPINGS, OWASP_ASI_MAPPINGS, CSA_ATF_MAPPINGS, REGULATORY_FRAMEWORKS, } from '@ai-sdlc/reference';
+//# sourceMappingURL=compliance-extended.js.map

package/dist/config.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Loads and validates .ai-sdlc/ resource YAML files using the reference
+ * implementation's schema validation.
+ *
+ * Unlike the dogfood config loader, this version does NOT import builder
+ * functions — it performs pure YAML loading and validation only.
+ */
+import { type Pipeline, type AgentRole, type QualityGate, type AutonomyPolicy, type AdapterBinding, type AdapterRegistry } from '@ai-sdlc/reference';
+export interface AiSdlcConfig {
+    pipeline?: Pipeline;
+    agentRole?: AgentRole;
+    qualityGate?: QualityGate;
+    autonomyPolicy?: AutonomyPolicy;
+    adapterBinding?: AdapterBinding;
+    adapterRegistry?: AdapterRegistry;
+}
+/**
+ * Load all YAML files from the given directory, validate each against
+ * the AI-SDLC JSON Schema, and return typed resources keyed by kind.
+ */
+export declare function loadConfig(configDir: string): AiSdlcConfig;
+/**
+ * Async variant of loadConfig that also scans for local adapter plugins.
+ */
+export declare function loadConfigAsync(configDir: string): Promise<AiSdlcConfig>;
+//# sourceMappingURL=config.d.ts.map

package/dist/config.js

@@ -0,0 +1,66 @@
+/**
+ * Loads and validates .ai-sdlc/ resource YAML files using the reference
+ * implementation's schema validation.
+ *
+ * Unlike the dogfood config loader, this version does NOT import builder
+ * functions — it performs pure YAML loading and validation only.
+ */
+import { readFileSync, readdirSync, existsSync } from 'node:fs';
+import { resolve, join } from 'node:path';
+import { parse as parseYaml } from 'yaml';
+import { validateResource, createAdapterRegistry, scanLocalAdapters, } from '@ai-sdlc/reference';
+const KIND_KEY = {
+    Pipeline: 'pipeline',
+    AgentRole: 'agentRole',
+    QualityGate: 'qualityGate',
+    AutonomyPolicy: 'autonomyPolicy',
+    AdapterBinding: 'adapterBinding',
+};
+/**
+ * Load all YAML files from the given directory, validate each against
+ * the AI-SDLC JSON Schema, and return typed resources keyed by kind.
+ */
+export function loadConfig(configDir) {
+    const dir = resolve(configDir);
+    if (!existsSync(dir)) {
+        return {};
+    }
+    const files = readdirSync(dir).filter((f) => f.endsWith('.yaml') || f.endsWith('.yml'));
+    const config = {};
+    for (const file of files) {
+        // Skip non-resource YAML files (e.g. manifest.yaml)
+        if (file === 'manifest.yaml')
+            continue;
+        const raw = readFileSync(resolve(dir, file), 'utf-8');
+        const doc = parseYaml(raw);
+        const result = validateResource(doc);
+        if (!result.valid) {
+            const msgs = (result.errors ?? []).map((e) => `  ${e.path}: ${e.message}`).join('\n');
+            throw new Error(`Validation failed for ${file}:\n${msgs}`);
+        }
+        const resource = result.data;
+        const key = KIND_KEY[resource.kind];
+        if (key) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            config[key] = resource;
+        }
+    }
+    return config;
+}
+/**
+ * Async variant of loadConfig that also scans for local adapter plugins.
+ */
+export async function loadConfigAsync(configDir) {
+    const config = loadConfig(configDir);
+    const registry = createAdapterRegistry();
+    try {
+        const scan = await scanLocalAdapters({ basePath: join(configDir, 'adapters') });
+        for (const m of scan.adapters)
+            registry.register(m);
+    }
+    catch {
+        /* no adapters dir — fine */
+    }
+    return { ...config, adapterRegistry: registry };
+}
+//# sourceMappingURL=config.js.map

package/dist/context-enrichment.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Context enrichment — finds relevant episodic memory and formats
+ * it into a structured prompt section for agent context injection.
+ *
+ * RFC reference: Phase 2 context enrichment.
+ */
+import type { StateStore } from './state/store.js';
+import type { EpisodicRecord } from './state/types.js';
+export interface EpisodeSearchCriteria {
+    files?: string[];
+    module?: string;
+    labels?: string[];
+    issueNumber?: number;
+    agentName?: string;
+}
+export interface ScoredEpisode {
+    episode: EpisodicRecord;
+    relevanceScore: number;
+}
+/**
+ * Find relevant episodes from the state store based on given criteria.
+ * Returns episodes sorted by relevance score (highest first).
+ */
+export declare function findRelevantEpisodes(store: StateStore, criteria: EpisodeSearchCriteria, limit?: number): ScoredEpisode[];
+/**
+ * Format episodic memory entries into a structured prompt section.
+ */
+export declare function formatEpisodicContext(episodes: ScoredEpisode[]): string;
+/**
+ * Top-level enrichment: find relevant episodes and format them.
+ */
+export declare function enrichAgentContext(store: StateStore, criteria: EpisodeSearchCriteria): string;
+//# sourceMappingURL=context-enrichment.d.ts.map

package/dist/context-enrichment.js

@@ -0,0 +1,125 @@
+/**
+ * Context enrichment — finds relevant episodic memory and formats
+ * it into a structured prompt section for agent context injection.
+ *
+ * RFC reference: Phase 2 context enrichment.
+ */
+/**
+ * Find relevant episodes from the state store based on given criteria.
+ * Returns episodes sorted by relevance score (highest first).
+ */
+export function findRelevantEpisodes(store, criteria, limit = 10) {
+    // Pull recent episodes (broad search)
+    const candidates = store.searchEpisodicRecords({ limit: 200 });
+    // Score each candidate
+    const scored = [];
+    for (const ep of candidates) {
+        let score = 0;
+        // Score by issue number match
+        if (criteria.issueNumber && ep.issueNumber === criteria.issueNumber) {
+            score += 5;
+        }
+        // Score by agent name match
+        if (criteria.agentName && ep.agentName === criteria.agentName) {
+            score += 2;
+        }
+        // Score by file overlap
+        if (criteria.files && criteria.files.length > 0 && ep.metadata) {
+            try {
+                const parsed = JSON.parse(ep.metadata);
+                const epFiles = parsed.filesChanged ?? parsed.files ?? [];
+                const overlap = criteria.files.filter((f) => epFiles.some((ef) => ef.includes(f) || f.includes(ef)));
+                score += overlap.length * 3;
+            }
+            catch {
+                // metadata not JSON
+            }
+        }
+        // Score by module match (check metadata or routing strategy)
+        if (criteria.module && ep.metadata) {
+            if (ep.metadata.includes(criteria.module)) {
+                score += 2;
+            }
+        }
+        // Score by labels
+        if (criteria.labels && criteria.labels.length > 0 && ep.metadata) {
+            for (const label of criteria.labels) {
+                if (ep.metadata.includes(label)) {
+                    score += 1;
+                }
+            }
+        }
+        // Bonus for regressions (more important context)
+        if (ep.isRegression === 1) {
+            score += 2;
+        }
+        // Bonus for failures (cautionary context)
+        if (ep.outcome === 'failure') {
+            score += 1;
+        }
+        // Time decay: reduce score for older episodes
+        if (ep.createdAt) {
+            const ageMs = Date.now() - new Date(ep.createdAt).getTime();
+            const ageDays = ageMs / (24 * 60 * 60 * 1000);
+            if (ageDays > 30)
+                score *= 0.5;
+            else if (ageDays > 7)
+                score *= 0.8;
+        }
+        if (score > 0) {
+            scored.push({ episode: ep, relevanceScore: score });
+        }
+    }
+    return scored.sort((a, b) => b.relevanceScore - a.relevanceScore).slice(0, limit);
+}
+/**
+ * Format episodic memory entries into a structured prompt section.
+ */
+export function formatEpisodicContext(episodes) {
+    if (episodes.length === 0) {
+        return '';
+    }
+    const lines = ['## Episodic Memory (relevant history)', ''];
+    for (const { episode } of episodes.slice(0, 5)) {
+        const outcome = episode.outcome === 'success' ? 'SUCCESS' : 'FAILURE';
+        const date = episode.createdAt?.split('T')[0] ?? 'unknown';
+        const agent = episode.agentName ? ` (${episode.agentName})` : '';
+        const regression = episode.isRegression === 1 ? ' [REGRESSION]' : '';
+        lines.push(`### ${outcome}${regression} — ${episode.pipelineType}${agent} (${date})`);
+        if (episode.errorMessage) {
+            lines.push(`Error: ${episode.errorMessage.slice(0, 200)}`);
+        }
+        if (episode.routingStrategy) {
+            lines.push(`Strategy: ${episode.routingStrategy}`);
+        }
+        if (episode.gatePassCount != null || episode.gateFailCount != null) {
+            lines.push(`Gates: ${episode.gatePassCount ?? 0} passed, ${episode.gateFailCount ?? 0} failed`);
+        }
+        if (episode.costUsd != null) {
+            lines.push(`Cost: $${episode.costUsd.toFixed(4)}`);
+        }
+        // Extract files from metadata
+        if (episode.metadata) {
+            try {
+                const parsed = JSON.parse(episode.metadata);
+                const files = parsed.filesChanged ?? parsed.files ?? [];
+                if (files.length > 0) {
+                    lines.push(`Files: ${files.slice(0, 5).join(', ')}${files.length > 5 ? ` (+${files.length - 5} more)` : ''}`);
+                }
+            }
+            catch {
+                // not JSON
+            }
+        }
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+/**
+ * Top-level enrichment: find relevant episodes and format them.
+ */
+export function enrichAgentContext(store, criteria) {
+    const episodes = findRelevantEpisodes(store, criteria);
+    return formatEpisodicContext(episodes);
+}
+//# sourceMappingURL=context-enrichment.js.map

package/dist/cost-governance.d.ts

@@ -0,0 +1,22 @@
+/**
+ * CostGovernancePlugin — orchestrator plugin that wires budget checks,
+ * circuit breaker, and cost alert evaluation into the pipeline lifecycle.
+ *
+ * Registered automatically when a Pipeline has a costPolicy.
+ */
+import type { CostPolicy } from '@ai-sdlc/reference';
+import type { OrchestratorPlugin, PluginContext, BeforeRunEvent, AfterRunEvent } from './plugin.js';
+export declare class CostGovernancePlugin implements OrchestratorPlugin {
+    private costPolicy;
+    name: string;
+    private costTracker?;
+    private notificationRouter?;
+    private log;
+    private budgetAmount?;
+    private budgetPeriod?;
+    constructor(costPolicy: CostPolicy);
+    initialize(ctx: PluginContext): void;
+    beforeRun(_event: BeforeRunEvent): Promise<void>;
+    afterRun(_event: AfterRunEvent): Promise<void>;
+}
+//# sourceMappingURL=cost-governance.d.ts.map