@getmikk/intent-engine 1.8.0 → 2.0.0

package/src/enforced-safety.ts

@@ -0,0 +1,305 @@
+import type { MikkContract, MikkLock, DependencyGraph } from '@getmikk/core'
+import { ImpactAnalyzer } from '@getmikk/core'
+
+/**
+ * EnforcedSafetyGates — blocks unsafe edits at edit-time.
+ *
+ * Unlike warnings, blocking gates PREVENT edits from being applied
+ * unless explicitly bypassed.
+ *
+ * Integration points:
+ * - Pre-commit hooks
+ * - IDE save handlers
+ * - CI/CD gates
+ * - MCP tool validation (mikk_before_edit)
+ */
+export interface SafetyGateResult {
+    canProceed: boolean
+    gate: string
+    reason: string
+    severity: 'BLOCKING' | 'WARNING'
+    bypassable: boolean
+    bypassCommand?: string
+    autoFixable: boolean
+    suggestedFix?: string
+}
+
+export interface SafetyGateConfig {
+    enforceOnSave: boolean
+    enforceOnCommit: boolean
+    enforceInCI: boolean
+    maxRiskScore: number
+    maxImpactNodes: number
+    requireTestsForChangedFiles: boolean
+    requireDocumentationForApiChanges: boolean
+    protectedModules: string[]
+}
+
+export class EnforcedSafetyGates {
+    private analyzer: ImpactAnalyzer
+
+    constructor(
+        private contract: MikkContract,
+        private lock: MikkLock,
+        graph: DependencyGraph,
+        private config: SafetyGateConfig,
+    ) {
+        this.analyzer = new ImpactAnalyzer(graph)
+    }
+
+    /** Run all safety gates before allowing edits. */
+    async validateEdits(
+        files: string[],
+        context?: { commitMessage?: string; branchName?: string; isTestRun?: boolean },
+    ): Promise<SafetyGateResult[]> {
+        return [
+            await this.checkRiskGate(files),
+            await this.checkScaleGate(files),
+            await this.checkProtectedModuleGate(files),
+            await this.checkBreakingChangeGate(files, context),
+            await this.checkTestCoverageGate(files),
+            await this.checkDocumentationGate(files),
+        ]
+    }
+
+    /** Returns whether all blocking gates passed. */
+    canProceed(results: SafetyGateResult[]): { allowed: boolean; blockingGates: string[] } {
+        const blocking = results.filter(r => !r.canProceed && r.severity === 'BLOCKING')
+        return { allowed: blocking.length === 0, blockingGates: blocking.map(r => r.gate) }
+    }
+
+    // ─── Gate implementations ──────────────────────────────────────────────
+
+    private async checkRiskGate(files: string[]): Promise<SafetyGateResult> {
+        const fileNodes = this.getFileNodes(files)
+
+        if (fileNodes.length === 0) {
+            return this.pass('RISK_SCORE', 'No tracked functions in modified files')
+        }
+
+        const impact = this.analyzer.analyze(fileNodes.map(n => n.id))
+        const risk = impact.riskScore
+
+        if (risk >= 90) {
+            return {
+                canProceed: false,
+                gate: 'RISK_SCORE',
+                reason: `Critical risk score: ${risk}/100. Changes could break significant portions of the system.`,
+                severity: 'BLOCKING',
+                bypassable: false,
+                autoFixable: false,
+                suggestedFix: 'Break changes into smaller increments or add comprehensive tests',
+            }
+        }
+        if (risk > this.config.maxRiskScore) {
+            return {
+                canProceed: false,
+                gate: 'RISK_SCORE',
+                reason: `High risk: ${risk}/100 exceeds threshold of ${this.config.maxRiskScore}`,
+                severity: 'BLOCKING',
+                bypassable: true,
+                bypassCommand: 'mikk safety bypass --gate=RISK_SCORE --reason="<explanation>"',
+                autoFixable: false,
+            }
+        }
+
+        return this.pass('RISK_SCORE', `Risk score ${risk} within acceptable limits`)
+    }
+
+    private async checkScaleGate(files: string[]): Promise<SafetyGateResult> {
+        const fileNodes = this.getFileNodes(files)
+
+        if (fileNodes.length === 0) {
+            return this.pass('IMPACT_SCALE', 'No tracked functions in modified files')
+        }
+
+        const impact = this.analyzer.analyze(fileNodes.map(n => n.id))
+        const count = impact.impacted.length
+        const hardLimit = this.config.maxImpactNodes * 2
+
+        if (count > hardLimit) {
+            return {
+                canProceed: false,
+                gate: 'IMPACT_SCALE',
+                reason: `Massive blast radius: ${count} functions affected. Hard limit: ${hardLimit}`,
+                severity: 'BLOCKING',
+                bypassable: false,
+                autoFixable: false,
+                suggestedFix: 'Split into multiple PRs or create a migration plan',
+            }
+        }
+        if (count > this.config.maxImpactNodes) {
+            return {
+                canProceed: false,
+                gate: 'IMPACT_SCALE',
+                reason: `Large impact: ${count} functions affected. Threshold: ${this.config.maxImpactNodes}`,
+                severity: 'BLOCKING',
+                bypassable: true,
+                bypassCommand: 'mikk safety bypass --gate=IMPACT_SCALE --reason="<explanation>"',
+                autoFixable: false,
+            }
+        }
+
+        return this.pass('IMPACT_SCALE', `Impact scale acceptable: ${count} functions`)
+    }
+
+    private async checkProtectedModuleGate(files: string[]): Promise<SafetyGateResult> {
+        const touchedProtected: string[] = []
+
+        for (const file of files) {
+            const norm = file.replace(/\\/g, '/')
+            const fileEntry = Object.values(this.lock.files).find(
+                f => f.path === norm || norm.endsWith(f.path),
+            )
+            // Guard: moduleId may be absent on file entries
+            if (fileEntry?.moduleId && this.config.protectedModules.includes(fileEntry.moduleId)) {
+                touchedProtected.push(fileEntry.moduleId)
+            }
+        }
+
+        const unique = [...new Set(touchedProtected)]
+        if (unique.length > 0) {
+            return {
+                canProceed: false,
+                gate: 'PROTECTED_MODULE',
+                reason: `Modified protected modules: ${unique.join(', ')}. These require architecture review.`,
+                severity: 'BLOCKING',
+                bypassable: false,
+                autoFixable: false,
+                suggestedFix: 'Request architecture review or schedule a change review meeting',
+            }
+        }
+
+        return this.pass('PROTECTED_MODULE', 'No protected modules touched')
+    }
+
+    private async checkBreakingChangeGate(
+        files: string[],
+        context?: { commitMessage?: string; branchName?: string },
+    ): Promise<SafetyGateResult> {
+        const fileNodes = this.getFileNodes(files)
+
+        // An exported function with callers is a breaking-change candidate
+        const exportedWithCallers = fileNodes.filter(n => {
+            const fn = this.lock.functions[n.id]
+            return fn?.isExported && fn.calledBy.length > 0
+        })
+
+        if (exportedWithCallers.length === 0) {
+            return this.pass('BREAKING_CHANGE', 'No exported API changes with existing callers detected')
+        }
+
+        const hasExplicitIntent =
+            context?.commitMessage?.toLowerCase().includes('breaking:') ||
+            context?.branchName?.toLowerCase().includes('breaking') ||
+            context?.commitMessage?.toLowerCase().includes('api change')
+
+        if (hasExplicitIntent) {
+            return this.pass(
+                'BREAKING_CHANGE',
+                `Exported API changes (${exportedWithCallers.length} functions) with explicit breaking intent`,
+            )
+        }
+
+        return {
+            canProceed: false,
+            gate: 'BREAKING_CHANGE',
+            reason: `${exportedWithCallers.length} exported function(s) with callers modified without explicit intent marker. Add "BREAKING:" to commit message.`,
+            severity: 'BLOCKING',
+            bypassable: true,
+            bypassCommand: 'git commit -m "BREAKING: <your message>"',
+            autoFixable: false,
+        }
+    }
+
+    private async checkTestCoverageGate(files: string[]): Promise<SafetyGateResult> {
+        if (!this.config.requireTestsForChangedFiles) {
+            return this.pass('TEST_COVERAGE', 'Test coverage gate disabled')
+        }
+
+        const fileNodes = this.getFileNodes(files)
+        if (fileNodes.length === 0) return this.pass('TEST_COVERAGE', 'No tracked functions in modified files')
+
+        const impact = this.analyzer.analyze(fileNodes.map(n => n.id))
+
+        const highRisk = impact.impacted.filter(id => {
+            const fn = this.lock.functions[id]
+            return fn && (fn.calledBy.length > 10 || fn.isExported)
+        })
+
+        const hasTests = files.some(
+            f => f.includes('.test.') || f.includes('.spec.') || f.includes('__tests__'),
+        )
+
+        if (highRisk.length > 0 && !hasTests) {
+            return {
+                canProceed: false,
+                gate: 'TEST_COVERAGE',
+                reason: `${highRisk.length} high-risk change(s) without test modifications`,
+                severity: 'BLOCKING',
+                bypassable: true,
+                bypassCommand: 'mikk safety bypass --gate=TEST_COVERAGE',
+                autoFixable: true,
+                suggestedFix: 'Add tests for changed functions or affected call paths',
+            }
+        }
+
+        return this.pass(
+            'TEST_COVERAGE',
+            hasTests ? 'Tests modified alongside changes' : 'No high-risk changes requiring tests',
+        )
+    }
+
+    private async checkDocumentationGate(files: string[]): Promise<SafetyGateResult> {
+        if (!this.config.requireDocumentationForApiChanges) {
+            return this.pass('DOCUMENTATION', 'Documentation gate disabled')
+        }
+
+        const docFiles = ['README.md', 'API.md', 'CHANGELOG.md', 'AGENTS.md']
+        const docsUpdated = files.some(f => docFiles.some(d => f.endsWith(d)))
+
+        const fileNodes = this.getFileNodes(files)
+        const hasSignificantApiChanges = fileNodes.some(n => {
+            const fn = this.lock.functions[n.id]
+            return fn?.isExported && fn.calledBy.length > 5
+        })
+
+        if (hasSignificantApiChanges && !docsUpdated) {
+            return {
+                canProceed: false,
+                gate: 'DOCUMENTATION',
+                reason: 'Significant API changes detected without documentation updates',
+                severity: 'BLOCKING',
+                bypassable: true,
+                bypassCommand: 'mikk safety bypass --gate=DOCUMENTATION',
+                autoFixable: false,
+                suggestedFix: 'Update README.md, API.md, or AGENTS.md with the changes',
+            }
+        }
+
+        return this.pass(
+            'DOCUMENTATION',
+            docsUpdated ? 'Documentation updated' : 'No significant API changes requiring docs',
+        )
+    }
+
+    // ─── Helpers ───────────────────────────────────────────────────────────
+
+    /** Collect graph-node IDs for every tracked function in the given files. */
+    private getFileNodes(files: string[]): Array<{ id: string }> {
+        const nodes: Array<{ id: string }> = []
+        for (const file of files) {
+            const norm = file.replace(/\\/g, '/')
+            for (const fn of Object.values(this.lock.functions)) {
+                if (fn.file === norm || fn.file.endsWith('/' + norm)) {
+                    nodes.push({ id: fn.id })
+                }
+            }
+        }
+        return nodes
+    }
+
+    private pass(gate: string, reason: string): SafetyGateResult {
+        return { canProceed: true, gate, reason, severity: 'WARNING', bypassable: true, autoFixable: false }
+    }
+}

package/src/explanation-engine.ts

@@ -0,0 +1,100 @@
+import type { ImpactResult, MikkLock } from '@getmikk/core'
+import type { DecisionResult, Explanation } from './types.js'
+
+/**
+ * ExplanationEngine — generates human-readable reasoning for code modification decisions.
+ * Explains WHY a change is safe or risky based on the quantitative graph analysis.
+ */
+export class ExplanationEngine {
+    /**
+     * @param lock  Optional lock reference — used to resolve module names accurately.
+     *              If omitted, module count is estimated from file paths.
+     */
+    constructor(private lock?: MikkLock) {}
+
+    explain(impact: ImpactResult, decision: DecisionResult): Explanation {
+        return {
+            summary:       this.getSummary(decision),
+            details:       this.getDetails(impact, decision),
+            riskBreakdown: this.getRiskBreakdown(impact),
+        }
+    }
+
+    private getSummary(decision: DecisionResult): string {
+        switch (decision.status) {
+            case 'APPROVED': return 'This change is safe and conforms to project policies.'
+            case 'WARNING':  return 'Change detected with non-trivial impact — proceed with caution.'
+            case 'BLOCKED':  return 'MODIFICATION BLOCKED: This change violates safety or architectural policies.'
+        }
+    }
+
+    private getDetails(impact: ImpactResult, decision: DecisionResult): string[] {
+        const details: string[] = []
+
+        if (impact.allImpacted.length === 0) {
+            details.push('No downstream symbols are affected by this change.')
+        } else {
+            details.push(`Affects ${impact.allImpacted.length} symbols across ${this.countModules(impact)} modules.`)
+            details.push(`Maximum risk score is ${impact.riskScore}/100.`)
+        }
+
+        if (impact.classified.critical.length > 0) {
+            details.push(`⚠ Critical: affects ${impact.classified.critical.length} symbol(s) in separate modules.`)
+        }
+
+        for (const r of decision.reasons) {
+            details.push(`Policy: ${r}`)
+        }
+
+        return details
+    }
+
+    private getRiskBreakdown(impact: ImpactResult): { symbol: string; reason: string; score: number }[] {
+        return [...impact.allImpacted]
+            .sort((a, b) => b.riskScore - a.riskScore)
+            .slice(0, 3)
+            .map(node => ({
+                symbol: node.label,
+                score:  node.riskScore,
+                reason: this.getRiskReason(node.riskScore),
+            }))
+    }
+
+    private getRiskReason(score: number): string {
+        if (score >= 90) return 'Direct critical dependency in protected module'
+        if (score >= 80) return 'Large downstream reach (potential side effects)'
+        if (score >= 60) return 'Cross-module propagation'
+        return 'Standard functional dependency'
+    }
+
+    /**
+     * Count distinct modules touched by the impact set.
+     *
+     * Preference order:
+     *  1. lock.functions[nodeId].moduleId  — accurate
+     *  2. heuristic from file path         — fallback when lock is absent
+     */
+    private countModules(impact: ImpactResult): number {
+        const modules = new Set<string>()
+
+        for (const node of impact.allImpacted) {
+            let moduleId: string | undefined
+
+            // Try to resolve via lock first
+            if (this.lock) {
+                moduleId = this.lock.functions[node.nodeId]?.moduleId
+            }
+
+            if (!moduleId) {
+                // Fallback: first meaningful path segment after stripping common prefixes
+                const parts = node.file.replace(/\\/g, '/').split('/')
+                const segIdx = parts.findIndex(p => p !== 'src' && p !== 'packages' && p !== 'apps')
+                moduleId = segIdx >= 0 ? parts[segIdx] : (parts[0] ?? 'root')
+            }
+
+            modules.add(moduleId)
+        }
+
+        return modules.size
+    }
+}

package/src/index.ts

@@ -3,6 +3,16 @@ export { ConflictDetector } from './conflict-detector.js'
 export { Suggester } from './suggester.js'
 export { PreflightPipeline } from './preflight.js'
 export { SemanticSearcher } from './semantic-searcher.js'
+export { IntentUnderstanding } from './intent-understanding.js'
+export { AutoCorrectionEngine } from './auto-correction.js'
+export { EnforcedSafetyGates } from './enforced-safety.js'
+export { PreEditValidation } from './pre-edit-validation.js'
+
 export type { SemanticMatch } from './semantic-searcher.js'
+export type { IntentContext, IntentAnalysis } from './intent-understanding.js'
+export type { CorrectionIssue, CorrectionResult } from './auto-correction.js'
+export type { SafetyGateResult, SafetyGateConfig } from './enforced-safety.js'
+export type { EditProposal, ValidationResult } from './pre-edit-validation.js'
+
 export type { Intent, Conflict, ConflictResult, Suggestion, PreflightResult, AIProviderConfig } from './types.js'
 export { IntentSchema } from './types.js'

package/src/intent-understanding.ts

@@ -0,0 +1,227 @@
+import type { ImpactResult, MikkContract, MikkLock } from '@getmikk/core'
+
+/**
+ * IntentUnderstanding - Analyzes if breaking changes are intentional.
+ *
+ * Understands developer intent through:
+ * 1. Explicit intent declarations ("REFACTOR:", "BREAKING:" in commit messages)
+ * 2. Change pattern analysis (rename vs bugfix vs new feature)
+ * 3. Context clues (branch name, PR description, file patterns)
+ */
+export interface IntentContext {
+    commitMessage?: string
+    branchName?: string
+    prDescription?: string
+    author?: string
+    filesChanged: string[]
+    changeType: 'refactor' | 'feature' | 'bugfix' | 'breaking' | 'unknown'
+    confidence: number
+}
+
+export interface IntentAnalysis {
+    isIntentionalBreakingChange: boolean
+    confidence: number
+    reasoning: string[]
+    suggestedActions: string[]
+    riskAcceptance: 'none' | 'low' | 'medium' | 'high'
+}
+
+export class IntentUnderstanding {
+    constructor(private contract: MikkContract, private lock: MikkLock) {}
+
+    /**
+     * Analyze if breaking changes are intentional based on context.
+     *
+     * NOTE: `impact` is typed as ImpactResult. ClassifiedImpact nodes expose
+     * `nodeId` (not `id` or `functionId`) — all node lookups use that field.
+     */
+    analyzeIntent(impact: ImpactResult, context: Partial<IntentContext> = {}): IntentAnalysis {
+        const reasoning: string[] = []
+        let confidence = 0.5
+        let isIntentional = false
+        let riskAcceptance: IntentAnalysis['riskAcceptance'] = 'none'
+
+        // 1. Check explicit markers in commit message
+        if (context.commitMessage) {
+            const msg = context.commitMessage.toLowerCase()
+            const breakingMarkers = ['breaking:', 'breaking change', 'refactor:', 'migration:', 'api change']
+            const found = breakingMarkers.find(m => msg.includes(m))
+
+            if (found) {
+                isIntentional = true
+                confidence += 0.3
+                reasoning.push(`Explicit breaking change marker found: "${found}"`)
+                riskAcceptance = 'high'
+            }
+
+            const safetyMarkers = ['fix:', 'hotfix:', 'patch:', 'bugfix:']
+            if (safetyMarkers.some(m => msg.includes(m))) {
+                confidence += 0.2
+                reasoning.push('Safety fix detected — changes should be minimal and safe')
+                if (riskAcceptance === 'none') riskAcceptance = 'low'
+            }
+        }
+
+        // 2. Analyze branch naming patterns
+        if (context.branchName) {
+            const branch = context.branchName.toLowerCase()
+            if (branch.includes('refactor') || branch.includes('breaking') || branch.includes('v2')) {
+                isIntentional = true
+                confidence += 0.2
+                reasoning.push(`Branch name "${context.branchName}" suggests intentional restructuring`)
+                if (riskAcceptance === 'none') riskAcceptance = 'medium'
+            }
+            if (branch.includes('hotfix') || branch.includes('patch')) {
+                reasoning.push('Hotfix branch — expect minimal, safe changes')
+                if (riskAcceptance === 'none') riskAcceptance = 'low'
+            }
+        }
+
+        // 3. Analyze change patterns
+        const changePattern = this.analyzeChangePattern(impact, context.filesChanged ?? [])
+        if (changePattern.isRename) {
+            isIntentional = true
+            confidence += 0.15
+            reasoning.push('Pattern suggests systematic rename/refactor')
+        }
+        if (changePattern.isSignatureChange) {
+            reasoning.push('Function signature changes detected')
+            if (!isIntentional) confidence -= 0.1
+        }
+
+        // 4. Check against contract migration policies
+        const migrationPhase = this.detectMigrationPhase(impact)
+        if (migrationPhase === 'planned') {
+            isIntentional = true
+            confidence += 0.25
+            reasoning.push('Changes align with planned migration in contract')
+            riskAcceptance = 'high'
+        }
+
+        // 5. Historical analysis
+        if (context.author) {
+            const pattern = this.analyzeAuthorPattern(context.author)
+            if (pattern === 'careful') {
+                confidence += 0.1
+                reasoning.push(`${context.author} has history of careful, safe changes`)
+            }
+        }
+
+        confidence = Math.max(0, Math.min(1, confidence))
+
+        const suggestedActions = this.generateSuggestions(impact, isIntentional, confidence, riskAcceptance)
+
+        return { isIntentionalBreakingChange: isIntentional, confidence, reasoning, suggestedActions, riskAcceptance }
+    }
+
+    // ─── Private helpers ───────────────────────────────────────────────────
+
+    private detectMigrationPhase(impact: ImpactResult): 'none' | 'planned' {
+        const decisions = this.contract.declared?.decisions ?? []
+
+        for (const decision of decisions) {
+            const text = `${decision.title ?? ''} ${decision.reason ?? ''}`.toLowerCase()
+            if (!text.includes('migration') && !text.includes('deprecat')) continue
+
+            // Use `nodeId` — the correct field on ClassifiedImpact
+            const affectedModules = new Set<string>()
+            for (const node of impact.allImpacted) {
+                const fn = this.lock.functions[node.nodeId]
+                if (fn?.moduleId) affectedModules.add(fn.moduleId)
+            }
+
+            const decisionModules = this.extractModulesFromDecision(`${decision.title ?? ''} ${decision.reason ?? ''}`)
+            if ([...affectedModules].some(m => decisionModules.includes(m))) return 'planned'
+        }
+
+        return 'none'
+    }
+
+    private extractModulesFromDecision(decision: string): string[] {
+        const modules = this.contract.declared?.modules ?? []
+        const mentioned: string[] = []
+        for (const mod of modules) {
+            if (
+                decision.toLowerCase().includes(mod.id.toLowerCase()) ||
+                decision.toLowerCase().includes(mod.name.toLowerCase())
+            ) {
+                mentioned.push(mod.id)
+            }
+        }
+        return mentioned
+    }
+
+    private analyzeChangePattern(
+        impact: ImpactResult,
+        filesChanged: string[],
+    ): { isRename: boolean; isSignatureChange: boolean; isNewFeature: boolean } {
+        const result = { isRename: false, isSignatureChange: false, isNewFeature: false }
+
+        const lockFilePaths = new Set(Object.keys(this.lock.files))
+        const norm = (f: string) => f.replace(/\\/g, '/')
+        const deletedFiles = filesChanged.filter(f => !lockFilePaths.has(norm(f)))
+        const addedFiles   = filesChanged.filter(f =>  lockFilePaths.has(norm(f)))
+
+        if (deletedFiles.length > 0 && addedFiles.length > 0) {
+            for (const deleted of deletedFiles) {
+                const base = deleted.split('/').pop()?.split('.')[0]
+                if (base && addedFiles.some(a => norm(a).includes(base))) {
+                    result.isRename = true
+                    break
+                }
+            }
+        }
+
+        // Use `nodeId` — correct field on ClassifiedImpact
+        for (const node of impact.allImpacted) {
+            const fn = this.lock.functions[node.nodeId]
+            if (fn?.params && fn.params.length > 0) {
+                result.isSignatureChange = true
+                break
+            }
+        }
+
+        const newExports = filesChanged.flatMap(file => {
+            const n = norm(file)
+            return Object.values(this.lock.functions).filter(
+                f => (f.file === n || f.file.endsWith('/' + n)) && f.isExported && f.calledBy.length === 0,
+            )
+        })
+        if (newExports.length > 3) result.isNewFeature = true
+
+        return result
+    }
+
+    private analyzeAuthorPattern(_author: string): 'careful' | 'normal' | 'aggressive' {
+        return 'normal'
+    }
+
+    private generateSuggestions(
+        impact: ImpactResult,
+        isIntentional: boolean,
+        confidence: number,
+        riskAcceptance: IntentAnalysis['riskAcceptance'],
+    ): string[] {
+        const out: string[] = []
+
+        if (isIntentional && confidence > 0.7) {
+            out.push('✓ Breaking change appears intentional — proceeding with caution')
+            if (impact.impacted.length > 10) out.push('Consider breaking this into smaller PRs for easier review')
+            out.push('Ensure tests exist for all impacted call paths')
+            out.push('Update relevant documentation for API changes')
+            if (riskAcceptance === 'high') out.push('Schedule deployment during low-traffic period')
+        } else if (impact.riskScore > 80) {
+            out.push('⚠ HIGH RISK: Breaking changes without explicit intent detected')
+            out.push('Add "BREAKING:" prefix to commit message if intentional')
+            out.push('Run full test suite before committing')
+            out.push('Consider creating a migration guide for consumers')
+        } else if (impact.impacted.length > 5) {
+            out.push('Review impacted functions to ensure changes are necessary')
+            out.push('Check if any changes can be made backward-compatible')
+        } else {
+            out.push('Changes appear low-risk — standard review process recommended')
+        }
+
+        return out
+    }
+}