@minionry/minion 0.7.36

package/dist/server/services/websocket/quality-fingerprint.js

@@ -0,0 +1,104 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { createHash } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import { isAbsolute, relative, resolve } from 'node:path';
+export function computeFingerprint(parts) {
+    return createHash('sha256').update(parts.join('\u0000'), 'utf8').digest('hex');
+}
+export function normalizeFindingPath(file, dirPath, baseDir) {
+    let rel = file;
+    if (isAbsolute(file))
+        rel = relative(dirPath, file);
+    else if (baseDir)
+        rel = relative(dirPath, resolve(baseDir, file));
+    return rel.replace(/\\/g, '/').replace(/^(\.\/)+/, '').replace(/\/+$/, '');
+}
+export function normalizeLineText(text) {
+    return text.replace(/\s+/g, ' ').trim();
+}
+export function lineTextOf(content, line) {
+    if (content === undefined || line === null || !Number.isInteger(line) || line < 1)
+        return '';
+    const lines = content.split('\n');
+    if (line > lines.length)
+        return '';
+    return normalizeLineText(lines[line - 1]);
+}
+export function digitlessTitle(title) {
+    return title.replace(/\d+/g, '');
+}
+export function ruleFindingParts(category, file, ruleKey, lineText) {
+    return [category, file, ruleKey, lineText];
+}
+export function templatedFindingParts(category, file, title) {
+    return [category, file, digitlessTitle(title)];
+}
+export function reviewFindingParts(category, file, lineText, evidence) {
+    const text = lineText || (evidence ? normalizeLineText(evidence) : '');
+    return [category, file, text];
+}
+export function duplicationParts(category, a, b) {
+    const [first, second] = a.file <= b.file ? [a, b] : [b, a];
+    return [category, first.file, second.file, first.lineText, second.lineText];
+}
+export function secretsParts(category, file, ruleId, ordinal) {
+    return [category, file, ruleId, String(ordinal)];
+}
+export function dependencyParts(category, file, packageName, advisoryId) {
+    return [category, file, packageName, advisoryId];
+}
+export function collectedContentReader(files) {
+    const byPath = new Map();
+    for (const f of files)
+        byPath.set(f.relativePath.replace(/\\/g, '/'), f.content);
+    return (file) => byPath.get(file);
+}
+export function diskContentReader(dirPath) {
+    const cache = new Map();
+    return (file) => {
+        if (cache.has(file))
+            return cache.get(file);
+        let content;
+        try {
+            content = readFileSync(resolve(dirPath, file), 'utf8');
+        }
+        catch {
+            content = undefined;
+        }
+        cache.set(file, content);
+        return content;
+    };
+}
+const REVIEW_CATEGORIES = new Set(['architecture', 'oop', 'security', 'bugs', 'performance', 'logic', 'maintainability']);
+const TEMPLATED_CATEGORIES = new Set(['file-length', 'function-length']);
+const RADON_TITLE = /\(\) has cyclomatic complexity \d+$/;
+const PRODUCER_STAMPED_CATEGORIES = new Set(['duplication', 'secrets', 'dependencies']);
+export function fingerprintParts(finding, ctx) {
+    const { category, title } = finding;
+    if (PRODUCER_STAMPED_CATEGORIES.has(category))
+        return null;
+    const file = normalizeFindingPath(finding.file, ctx.dirPath);
+    if (TEMPLATED_CATEGORIES.has(category) || (category === 'complexity' && RADON_TITLE.test(title))) {
+        return templatedFindingParts(category, file, title);
+    }
+    const lineText = lineTextOf(ctx.contentOf(file), finding.line);
+    if (REVIEW_CATEGORIES.has(category))
+        return reviewFindingParts(category, file, lineText, finding.evidence);
+    return ruleFindingParts(category, file, title, lineText);
+}
+export function fingerprintFinding(finding, ctx) {
+    const parts = fingerprintParts(finding, ctx);
+    return parts ? computeFingerprint(parts) : undefined;
+}
+export function stampFingerprints(findings, ctx) {
+    for (const finding of findings) {
+        finding.file = normalizeFindingPath(finding.file, ctx.dirPath);
+        if (finding.fingerprint)
+            continue;
+        const fingerprint = fingerprintFinding(finding, ctx);
+        if (fingerprint)
+            finding.fingerprint = fingerprint;
+    }
+    return findings;
+}

package/dist/server/services/websocket/quality-grading.js

@@ -0,0 +1,575 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+const SECURITY_CATEGORIES = new Set(['security', 'secrets', 'dependencies']);
+const RELIABILITY_CATEGORIES = new Set([
+    'bugs',
+    'logic',
+    'performance',
+    'complexity',
+    'build',
+    'coverage',
+    'error-handling',
+]);
+const MAINTAINABILITY_CATEGORIES = new Set([
+    'lint',
+    'linting',
+    'format',
+    'file-length',
+    'function-length',
+    'parameters',
+    'nesting',
+    'returns',
+    'tech-debt',
+    'duplication',
+    'documentation',
+    'architecture',
+    'oop',
+    'maintainability',
+]);
+export function categoryToDimension(category) {
+    if (SECURITY_CATEGORIES.has(category))
+        return 'security';
+    if (RELIABILITY_CATEGORIES.has(category))
+        return 'reliability';
+    if (MAINTAINABILITY_CATEGORIES.has(category))
+        return 'maintainability';
+    return 'maintainability';
+}
+const ARCHITECTURE_CATEGORIES = new Set(['architecture', 'oop']);
+const BASE_BAND_TOP = {
+    A: 100,
+    B: 89,
+    C: 79,
+    F: 69,
+};
+const BASE_BAND_BOTTOM = {
+    A: 90,
+    B: 80,
+    C: 70,
+    F: 56,
+};
+export function scoreToGrade(score) {
+    if (score >= 97)
+        return 'A+';
+    if (score >= 93)
+        return 'A';
+    if (score >= 90)
+        return 'A-';
+    if (score >= 87)
+        return 'B+';
+    if (score >= 83)
+        return 'B';
+    if (score >= 80)
+        return 'B-';
+    if (score >= 77)
+        return 'C+';
+    if (score >= 73)
+        return 'C';
+    if (score >= 70)
+        return 'C-';
+    if (score >= 65)
+        return 'F+';
+    if (score >= 56)
+        return 'F';
+    return 'F-';
+}
+export function gradeFromScore(score) {
+    const full = scoreToGrade(score);
+    return baseGradeOf(full);
+}
+function baseGradeOf(g) {
+    if (g === 'N/A' || g === 'D')
+        return g;
+    if (g.startsWith('A'))
+        return 'A';
+    if (g.startsWith('B'))
+        return 'B';
+    if (g.startsWith('C'))
+        return 'C';
+    return 'F';
+}
+function scoreInBand(grade, position) {
+    const clamped = Math.max(0, Math.min(1, position));
+    const bottom = BASE_BAND_BOTTOM[grade];
+    const top = BASE_BAND_TOP[grade];
+    return Math.round(bottom + (top - bottom) * clamped);
+}
+function isSeverity(s) {
+    return s === 'critical' || s === 'high' || s === 'medium' || s === 'low';
+}
+function countSeverities(findings) {
+    const counts = { critical: 0, high: 0, medium: 0, low: 0, total: 0 };
+    for (const f of findings) {
+        if (!isSeverity(f.severity))
+            continue;
+        counts[f.severity]++;
+        counts.total++;
+    }
+    return counts;
+}
+function worstSeverity(counts) {
+    if (counts.critical > 0)
+        return 'critical';
+    if (counts.high > 0)
+        return 'high';
+    if (counts.medium > 0)
+        return 'medium';
+    if (counts.low > 0)
+        return 'low';
+    return null;
+}
+function gradeSecurity(findings) {
+    const counts = countSeverities(findings);
+    const worst = worstSeverity(counts);
+    if (counts.total === 0) {
+        return makeDimension('security', 100, '0 security findings', 0, null);
+    }
+    if (counts.critical > 0) {
+        return makeDimension('security', Math.max(0, 55 - counts.critical * 5), `${counts.critical} critical-severity security ${pluralize('issue', counts.critical)}`, counts.total, worst);
+    }
+    let baseGrade;
+    let position;
+    let rationale;
+    if (counts.high > 0) {
+        baseGrade = 'F';
+        position = 1 / (1 + counts.high);
+        rationale = `${counts.high} high-severity security ${pluralize('issue', counts.high)}`;
+    }
+    else if (counts.medium > 0) {
+        baseGrade = 'C';
+        position = 1 / (1 + counts.medium);
+        rationale = `${counts.medium} medium-severity security ${pluralize('issue', counts.medium)}`;
+    }
+    else {
+        baseGrade = 'B';
+        position = 1 / Math.max(1, counts.low);
+        rationale = `${counts.low} low-severity security ${pluralize('issue', counts.low)}`;
+    }
+    const score = scoreInBand(baseGrade, position);
+    return makeDimension('security', score, rationale, counts.total, worst);
+}
+function reliabilityByCount(n) {
+    const label = `${n} reliability ${pluralize('issue', n)}`;
+    if (n <= 2)
+        return { grade: 'A', position: 1 - n / 2, label };
+    if (n <= 6)
+        return { grade: 'B', position: 1 - (n - 2) / 4, label };
+    if (n <= 15)
+        return { grade: 'C', position: 1 - (n - 6) / 9, label };
+    return { grade: 'F', position: 1 / (1 + (n - 15) / 15), label };
+}
+function reliabilityByDensity(n, kloc) {
+    const density = n / kloc;
+    const label = `${roundOne(density)} reliability ${pluralize('issue', n)} / KLOC`;
+    if (density < 1.5)
+        return { grade: 'A', position: 1 - density / 1.5, label };
+    if (density < 4)
+        return { grade: 'B', position: 1 - (density - 1.5) / 2.5, label };
+    if (density < 8)
+        return { grade: 'C', position: 1 - (density - 4) / 4, label };
+    return { grade: 'F', position: 1 / (1 + (density - 8) / 8), label };
+}
+function reliabilityEscape(counts) {
+    if (counts.critical > 0) {
+        return { grade: 'F', note: `${counts.critical} critical-severity ${pluralize('bug', counts.critical)}` };
+    }
+    if (counts.high > 0) {
+        return { grade: 'C', note: `${counts.high} high-severity ${pluralize('bug', counts.high)}` };
+    }
+    return null;
+}
+function gradeReliability(findings, totalLines) {
+    const counts = countSeverities(findings);
+    const worst = worstSeverity(counts);
+    const kloc = Math.max(totalLines / 1000, 1.0);
+    if (counts.total === 0) {
+        return makeDimension('reliability', 100, '0 reliability findings', 0, null);
+    }
+    if (counts.low <= 1 && counts.medium === 0 && counts.high === 0 && counts.critical === 0) {
+        return makeDimension('reliability', scoreInBand('A', 0.5), '1 low-severity reliability issue', counts.total, worst);
+    }
+    const band = kloc < 5 ? reliabilityByCount(counts.total) : reliabilityByDensity(counts.total, kloc);
+    const severityCap = reliabilityEscape(counts);
+    const useCap = severityCap && baseIsWorse(severityCap.grade, band.grade);
+    const finalGrade = useCap ? severityCap.grade : band.grade;
+    const finalPosition = useCap ? 0.5 : band.position;
+    const rationale = useCap ? `${band.label}, ${severityCap.note}` : band.label;
+    return makeDimension('reliability', scoreInBand(finalGrade, finalPosition), rationale, counts.total, worst);
+}
+function maintainabilityByCount(n) {
+    const label = `${n} maintainability ${pluralize('issue', n)}`;
+    if (n <= 5)
+        return { grade: 'A', position: 1 - n / 5, label };
+    if (n <= 15)
+        return { grade: 'B', position: 1 - (n - 5) / 10, label };
+    if (n <= 30)
+        return { grade: 'C', position: 1 - (n - 15) / 15, label };
+    return { grade: 'F', position: 1 / (1 + (n - 30) / 30), label };
+}
+function maintainabilityByDensity(n, kloc) {
+    const density = n / kloc;
+    const label = `${roundOne(density)} ${pluralize('issue', n)} / KLOC`;
+    if (density < 5)
+        return { grade: 'A', position: 1 - density / 5, label };
+    if (density < 10)
+        return { grade: 'B', position: 1 - (density - 5) / 5, label };
+    if (density < 25)
+        return { grade: 'C', position: 1 - (density - 10) / 15, label };
+    return { grade: 'F', position: 1 / (1 + (density - 25) / 25), label };
+}
+function maintainabilityEscape(counts) {
+    if (counts.critical > 0) {
+        return { grade: 'F', note: `${counts.critical} critical-severity ${pluralize('issue', counts.critical)}` };
+    }
+    if (counts.high > 0) {
+        return { grade: 'C', note: `${counts.high} high-severity ${pluralize('issue', counts.high)}` };
+    }
+    return null;
+}
+function gradeMaintainability(findings, totalLines) {
+    const counts = countSeverities(findings);
+    const kloc = Math.max(totalLines / 1000, 1.0);
+    if (counts.total === 0) {
+        return makeDimension('maintainability', 100, '0 maintainability findings', 0, null);
+    }
+    const band = kloc < 5 ? maintainabilityByCount(counts.total) : maintainabilityByDensity(counts.total, kloc);
+    const severityCap = maintainabilityEscape(counts);
+    const useCap = severityCap && baseIsWorse(severityCap.grade, band.grade);
+    const finalGrade = useCap ? severityCap.grade : band.grade;
+    const finalPosition = useCap ? 0.5 : band.position;
+    const rationale = useCap ? `${band.label}, ${severityCap.note}` : band.label;
+    return makeDimension('maintainability', scoreInBand(finalGrade, finalPosition), rationale, counts.total, worstSeverity(counts));
+}
+function archDropCount(archFindings) {
+    let highCount = 0;
+    let criticalCount = 0;
+    for (const f of archFindings) {
+        if (f.severity === 'critical')
+            criticalCount++;
+        else if (f.severity === 'high')
+            highCount++;
+    }
+    if (criticalCount >= 1)
+        return 2;
+    if (highCount >= 2)
+        return 2;
+    if (highCount >= 1)
+        return 1;
+    return 0;
+}
+const BASE_LETTERS = ['A', 'B', 'C', 'F'];
+function gradeModifier(grade) {
+    if (grade.endsWith('+'))
+        return '+';
+    if (grade.endsWith('-'))
+        return '-';
+    return '';
+}
+function applyModifierToTargetBase(targetBase, modifier) {
+    if (targetBase === 'F') {
+        if (modifier === '+')
+            return 'F+';
+        if (modifier === '-')
+            return 'F-';
+        return 'F';
+    }
+    if (modifier === '+')
+        return `${targetBase}+`;
+    if (modifier === '-')
+        return `${targetBase}-`;
+    return targetBase;
+}
+function dropGradeByLetters(grade, letters) {
+    if (letters <= 0 || grade === 'N/A' || grade === 'D')
+        return grade;
+    const baseLetter = baseGradeOf(grade);
+    const baseIdx = BASE_LETTERS.indexOf(baseLetter);
+    if (baseIdx === -1)
+        return grade;
+    const targetBaseIdx = baseIdx + letters;
+    if (targetBaseIdx > 3)
+        return 'F-';
+    const targetBase = BASE_LETTERS[targetBaseIdx];
+    return applyModifierToTargetBase(targetBase, gradeModifier(grade));
+}
+function applyArchPenalty(dim, archFindings) {
+    const drop = archDropCount(archFindings);
+    if (drop === 0)
+        return dim;
+    const dropped = dropGradeByLetters(dim.grade, drop);
+    if (dropped === dim.grade)
+        return dim;
+    const archCount = archFindings.length;
+    const noun = pluralize('architectural finding', archCount);
+    const note = `dropped ${drop} ${pluralize('letter', drop)} by ${archCount} ${noun}`;
+    return {
+        ...dim,
+        grade: dropped,
+        score: anchorScoreToGrade(dropped, dim.score),
+        rationale: dim.rationale === '0 maintainability findings' || dim.findingCount === 0
+            ? note
+            : `${dim.rationale}; ${note}`,
+    };
+}
+function anchorScoreToGrade(grade, originalScore) {
+    if (grade === 'N/A' || grade === 'D')
+        return originalScore;
+    const ranges = {
+        'A+': [97, 100], A: [93, 96], 'A-': [90, 92],
+        'B+': [87, 89], B: [83, 86], 'B-': [80, 82],
+        'C+': [77, 79], C: [73, 76], 'C-': [70, 72],
+        'F+': [65, 69], F: [56, 64], 'F-': [0, 55],
+    };
+    const [lo, hi] = ranges[grade];
+    if (originalScore >= lo && originalScore <= hi)
+        return originalScore;
+    return Math.round((lo + hi) / 2);
+}
+const BASE_RANK = { F: 1, C: 2, B: 3, A: 4 };
+function baseIsWorse(a, b) {
+    return BASE_RANK[a] < BASE_RANK[b];
+}
+const FULL_RANK = {
+    'F-': 0, F: 1, 'F+': 2,
+    'C-': 3, C: 4, 'C+': 5,
+    'B-': 6, B: 7, 'B+': 8,
+    'A-': 9, A: 10, 'A+': 11,
+};
+function gradeRank(g) {
+    if (g === 'N/A')
+        return -1;
+    if (g === 'D')
+        return 1.5;
+    return FULL_RANK[g];
+}
+function worstOf(grades) {
+    let worst = 'A+';
+    for (const g of grades) {
+        if (g === 'N/A')
+            continue;
+        if (gradeRank(g) < gradeRank(worst))
+            worst = g;
+    }
+    return worst;
+}
+function pluralize(word, n) {
+    return n === 1 ? word : `${word}s`;
+}
+function roundOne(n) {
+    return Math.round(n * 10) / 10;
+}
+function dimensionDisplayName(name) {
+    return name.charAt(0).toUpperCase() + name.slice(1);
+}
+function makeDimension(name, score, rationale, findingCount, worst) {
+    return {
+        name,
+        score,
+        grade: scoreToGrade(score),
+        rationale,
+        available: true,
+        findingCount,
+        worstSeverity: worst,
+    };
+}
+function naDimension(name) {
+    return {
+        name,
+        score: 0,
+        grade: 'N/A',
+        rationale: 'No tools available to evaluate',
+        available: false,
+        findingCount: 0,
+        worstSeverity: null,
+    };
+}
+function bucketByDimension(findings) {
+    const security = [];
+    const reliability = [];
+    const maintainability = [];
+    const architecture = [];
+    for (const f of findings) {
+        if (ARCHITECTURE_CATEGORIES.has(f.category))
+            architecture.push(f);
+        const dim = categoryToDimension(f.category);
+        if (dim === 'security')
+            security.push(f);
+        else if (dim === 'reliability')
+            reliability.push(f);
+        else
+            maintainability.push(f);
+    }
+    return { security, reliability, maintainability, architecture };
+}
+function isDimensionAvailable(dim, hasFindings, options) {
+    if (options?.forceNA?.has(dim))
+        return false;
+    const explicit = options?.availableDimensions;
+    if (explicit)
+        return explicit.has(dim);
+    return dim === 'maintainability' ? true : hasFindings;
+}
+function computeOverall(availableDims) {
+    if (availableDims.length === 0) {
+        return { grade: 'N/A', score: 0 };
+    }
+    const grades = availableDims.map((d) => d.grade);
+    const scores = availableDims.map((d) => d.score);
+    const avg = scores.reduce((s, n) => s + n, 0) / scores.length;
+    const worst = worstOf(grades);
+    const blendedScore = Math.round(Math.min(avg, Math.min(...scores)));
+    return { grade: worst, score: anchorScoreToGrade(worst, blendedScore) };
+}
+export function computeQualityRating(allFindings, totalLines, options) {
+    const buckets = bucketByDimension(allFindings);
+    const security = isDimensionAvailable('security', buckets.security.length > 0, options)
+        ? gradeSecurity(buckets.security)
+        : naDimension('security');
+    const reliabilityRaw = isDimensionAvailable('reliability', buckets.reliability.length > 0, options)
+        ? gradeReliability(buckets.reliability, totalLines)
+        : naDimension('reliability');
+    const maintainabilityRaw = isDimensionAvailable('maintainability', true, options)
+        ? gradeMaintainability(buckets.maintainability, totalLines)
+        : naDimension('maintainability');
+    const archFindings = buckets.architecture;
+    const maintainability = maintainabilityRaw.available
+        ? applyArchPenalty(maintainabilityRaw, archFindings)
+        : maintainabilityRaw;
+    const dimensions = [security, reliabilityRaw, maintainability];
+    const availableDims = dimensions.filter((d) => d.available);
+    const overall = computeOverall(availableDims);
+    const qualityGate = computeQualityGate(security, reliabilityRaw, archFindings.length);
+    const gradeRationale = computeGradeRationale(availableDims, overall.grade, allFindings.length);
+    return {
+        overall,
+        dimensions,
+        qualityGate,
+        gradeRationale,
+    };
+}
+const READINESS_SECURITY_CATEGORIES = new Set(['security', 'secrets', 'dependencies']);
+const READINESS_RELIABILITY_CATEGORIES = new Set(['build', 'bugs', 'logic', 'error-handling']);
+const SEVERITY_RANK = { critical: 4, high: 3, medium: 2, low: 1 };
+function worstSeverityRank(findings) {
+    let worst = 0;
+    for (const f of findings) {
+        if (isSeverity(f.severity))
+            worst = Math.max(worst, SEVERITY_RANK[f.severity]);
+    }
+    return worst;
+}
+function formatBlocker(f) {
+    const loc = f.line ? `${f.file}:${f.line}` : f.file;
+    return `${loc} — ${f.title}`;
+}
+function buildReadinessVerdict(level, security, reliability, maintBroken) {
+    const gating = [...security, ...reliability];
+    if (level === 'blocked') {
+        const crit = gating.filter((f) => f.severity === 'critical');
+        return {
+            level,
+            headline: 'Blocked',
+            rationale: `${crit.length} critical ${pluralize('issue', crit.length)} must be fixed before this can run.`,
+            blockers: crit.slice(0, 5).map(formatBlocker),
+        };
+    }
+    if (level === 'testing') {
+        const blocking = gating.filter((f) => f.severity === 'high' || (READINESS_SECURITY_CATEGORIES.has(f.category) && f.severity === 'medium'));
+        return {
+            level,
+            headline: 'Ready for testing',
+            rationale: 'Safe to run in a test environment. Resolve the flagged security/reliability issues before merging to develop.',
+            blockers: blocking.slice(0, 5).map(formatBlocker),
+        };
+    }
+    if (level === 'develop') {
+        return {
+            level,
+            headline: 'Ready for develop',
+            rationale: maintBroken
+                ? 'Safe to merge to the develop branch. Clean up maintainability before a production release.'
+                : 'Safe to merge to the develop branch. A few non-blocking issues remain before production.',
+            blockers: [],
+        };
+    }
+    if (level === 'insufficient-data') {
+        return {
+            level,
+            headline: 'Insufficient data',
+            rationale: 'Security and reliability were never assessed — no tools ran and no findings exist to judge. This is not a clean bill of health; it means nothing has been checked yet.',
+            blockers: [],
+        };
+    }
+    return {
+        level,
+        headline: 'Ready for production',
+        rationale: gating.length === 0
+            ? 'No blocking security or reliability issues — safe to ship.'
+            : 'Security and reliability are clean — safe to ship.',
+        blockers: [],
+    };
+}
+export function computeReadiness(dimensions, prodGatingFindings) {
+    const security = prodGatingFindings.filter((f) => READINESS_SECURITY_CATEGORIES.has(f.category));
+    const reliability = prodGatingFindings.filter((f) => READINESS_RELIABILITY_CATEGORIES.has(f.category));
+    const secRank = worstSeverityRank(security);
+    const relRank = worstSeverityRank(reliability);
+    const secDim = dimensions.find((d) => d.name === 'security');
+    const relDim = dimensions.find((d) => d.name === 'reliability');
+    const maint = dimensions.find((d) => d.name === 'maintainability');
+    const maintBroken = !!maint && maint.available && isFTier(maint.grade);
+    const maintHasSignal = !!maint && maint.available && maint.findingCount > 0;
+    const insufficientData = !secDim?.available && !relDim?.available && !maintHasSignal;
+    let level;
+    if (secRank >= SEVERITY_RANK.critical || relRank >= SEVERITY_RANK.critical) {
+        level = 'blocked';
+    }
+    else if (secRank >= SEVERITY_RANK.medium || relRank >= SEVERITY_RANK.high) {
+        level = 'testing';
+    }
+    else if (secRank <= SEVERITY_RANK.low && relRank <= SEVERITY_RANK.low && !maintBroken) {
+        level = insufficientData ? 'insufficient-data' : 'production';
+    }
+    else {
+        level = 'develop';
+    }
+    return buildReadinessVerdict(level, security, reliability, maintBroken);
+}
+function isFTier(g) {
+    return g === 'F+' || g === 'F' || g === 'F-' || g === 'D';
+}
+function isCorWorse(g) {
+    return baseGradeOf(g) === 'C' || isFTier(g);
+}
+function computeQualityGate(security, reliability, archFindingCount) {
+    const failingConditions = [];
+    if (security.available && isCorWorse(security.grade)) {
+        failingConditions.push(`Security grade ${security.grade} — ${security.rationale}`);
+    }
+    if (reliability.available && isFTier(reliability.grade)) {
+        failingConditions.push(`Reliability grade ${reliability.grade} — ${reliability.rationale}`);
+    }
+    if (archFindingCount >= 2) {
+        failingConditions.push(`${archFindingCount} architectural findings`);
+    }
+    return {
+        passed: failingConditions.length === 0,
+        failingConditions,
+    };
+}
+function computeGradeRationale(availableDims, overallGrade, totalFindingCount) {
+    if (totalFindingCount === 0) {
+        return 'Clean — no findings detected';
+    }
+    if (availableDims.length === 0 || overallGrade === 'N/A') {
+        return 'No dimensions available to grade';
+    }
+    const firstBase = baseGradeOf(availableDims[0].grade);
+    const allSameBase = availableDims.every((d) => baseGradeOf(d.grade) === firstBase);
+    if (allSameBase) {
+        return `All dimensions ${firstBase}-tier — consistent quality`;
+    }
+    const worstDim = availableDims.find((d) => d.grade === overallGrade) ??
+        availableDims[0];
+    return `Capped at ${overallGrade} by ${dimensionDisplayName(worstDim.name)} (${worstDim.rationale})`;
+}