mustflow 2.70.0 → 2.74.0

package/dist/cli/script-packs/core-text-budget.js

@@ -0,0 +1,241 @@
+import { printUsageError, renderHelp } from '../lib/cli-output.js';
+import { t } from '../lib/i18n.js';
+import { formatCliOptionParseError, getParsedCliStringOption, hasCliOptionToken, hasParsedCliOption, parseCliOptions, } from '../lib/option-parser.js';
+import { resolveMustflowRoot } from '../lib/project-root.js';
+import { inspectTextBudget, TEXT_BUDGET_SCRIPT_REF, TEXT_BUDGET_UNITS, } from '../../core/text-budget.js';
+const TEXT_BUDGET_OPTIONS = [
+    { name: '--json', kind: 'boolean' },
+    { name: '--min', kind: 'string' },
+    { name: '--max', kind: 'string' },
+    { name: '--exact', kind: 'string' },
+    { name: '--unit', kind: 'string' },
+    { name: '--json-pointer', kind: 'string' },
+];
+export function getCoreTextBudgetHelp(lang = 'en') {
+    return renderHelp({
+        usage: 'mf script-pack run core/text-budget check <path...> [options]',
+        summary: t(lang, 'textBudget.help.summary'),
+        options: [
+            { label: '--min <count>', description: t(lang, 'textBudget.help.option.min') },
+            { label: '--max <count>', description: t(lang, 'textBudget.help.option.max') },
+            { label: '--exact <count>', description: t(lang, 'textBudget.help.option.exact') },
+            { label: '--unit <unit>', description: t(lang, 'textBudget.help.option.unit') },
+            { label: '--json-pointer <pointer>', description: t(lang, 'textBudget.help.option.jsonPointer') },
+            { label: '--json', description: t(lang, 'cli.option.json') },
+            { label: '-h, --help', description: t(lang, 'cli.option.help') },
+        ],
+        examples: [
+            'mf script-pack run core/text-budget check README.md --max 5000',
+            'mf script-pack run core/text-budget check package.json --json-pointer /description --max 80 --json',
+            'mf script-pack run core/text-budget check docs/intro.md --min 20 --max 120 --unit word',
+        ],
+        exitCodes: [
+            { label: '0', description: t(lang, 'textBudget.help.exit.ok') },
+            { label: '1', description: t(lang, 'textBudget.help.exit.fail') },
+        ],
+    }, lang);
+}
+function parseNonNegativeInteger(value, option, lang) {
+    if (value === null) {
+        return { value: null };
+    }
+    if (!/^(?:0|[1-9]\d*)$/u.test(value)) {
+        return { value: null, error: t(lang, 'textBudget.error.invalidNumber', { option, value }) };
+    }
+    const parsed = Number(value);
+    if (!Number.isSafeInteger(parsed)) {
+        return { value: null, error: t(lang, 'textBudget.error.invalidNumber', { option, value }) };
+    }
+    return { value: parsed };
+}
+function parseTextBudgetUnit(value, lang) {
+    if (value === null) {
+        return { value: 'grapheme' };
+    }
+    if (TEXT_BUDGET_UNITS.includes(value)) {
+        return { value: value };
+    }
+    return {
+        value: 'grapheme',
+        error: t(lang, 'textBudget.error.invalidUnit', { unit: value, allowed: TEXT_BUDGET_UNITS.join(', ') }),
+    };
+}
+function parseTextBudgetOptions(args, lang) {
+    const [action, ...rest] = args;
+    const parsed = parseCliOptions(rest, TEXT_BUDGET_OPTIONS, {
+        allowPositionals: true,
+        allowEmptyStringValues: true,
+    });
+    const json = hasParsedCliOption(parsed, '--json');
+    const min = parseNonNegativeInteger(getParsedCliStringOption(parsed, '--min'), '--min', lang);
+    const max = parseNonNegativeInteger(getParsedCliStringOption(parsed, '--max'), '--max', lang);
+    const exact = parseNonNegativeInteger(getParsedCliStringOption(parsed, '--exact'), '--exact', lang);
+    const unit = parseTextBudgetUnit(getParsedCliStringOption(parsed, '--unit'), lang);
+    const jsonPointer = getParsedCliStringOption(parsed, '--json-pointer');
+    if (action !== 'check') {
+        return {
+            action: 'check',
+            json,
+            paths: parsed.positionals,
+            min: min.value,
+            max: max.value,
+            exact: exact.value,
+            unit: unit.value,
+            jsonPointer,
+            error: action ? t(lang, 'textBudget.error.unknownAction', { action }) : t(lang, 'textBudget.error.missingAction'),
+        };
+    }
+    if (parsed.error) {
+        return {
+            action,
+            json,
+            paths: parsed.positionals,
+            min: min.value,
+            max: max.value,
+            exact: exact.value,
+            unit: unit.value,
+            jsonPointer,
+            error: formatCliOptionParseError(parsed.error, lang),
+        };
+    }
+    for (const candidate of [min, max, exact, unit]) {
+        if (candidate.error) {
+            return {
+                action,
+                json,
+                paths: parsed.positionals,
+                min: min.value,
+                max: max.value,
+                exact: exact.value,
+                unit: unit.value,
+                jsonPointer,
+                error: candidate.error,
+            };
+        }
+    }
+    if (parsed.positionals.length === 0) {
+        return {
+            action,
+            json,
+            paths: parsed.positionals,
+            min: min.value,
+            max: max.value,
+            exact: exact.value,
+            unit: unit.value,
+            jsonPointer,
+            error: t(lang, 'textBudget.error.missingPath'),
+        };
+    }
+    if (exact.value !== null && (min.value !== null || max.value !== null)) {
+        return {
+            action,
+            json,
+            paths: parsed.positionals,
+            min: min.value,
+            max: max.value,
+            exact: exact.value,
+            unit: unit.value,
+            jsonPointer,
+            error: t(lang, 'textBudget.error.exactConflict'),
+        };
+    }
+    if (exact.value === null && min.value === null && max.value === null) {
+        return {
+            action,
+            json,
+            paths: parsed.positionals,
+            min: min.value,
+            max: max.value,
+            exact: exact.value,
+            unit: unit.value,
+            jsonPointer,
+            error: t(lang, 'textBudget.error.missingBudget'),
+        };
+    }
+    if (min.value !== null && max.value !== null && min.value > max.value) {
+        return {
+            action,
+            json,
+            paths: parsed.positionals,
+            min: min.value,
+            max: max.value,
+            exact: exact.value,
+            unit: unit.value,
+            jsonPointer,
+            error: t(lang, 'textBudget.error.minGreaterThanMax'),
+        };
+    }
+    return {
+        action,
+        json,
+        paths: parsed.positionals,
+        min: min.value,
+        max: max.value,
+        exact: exact.value,
+        unit: unit.value,
+        jsonPointer,
+    };
+}
+function renderBudget(report) {
+    if (report.policy.exact !== null) {
+        return `exact ${report.policy.exact} ${report.policy.unit}`;
+    }
+    const lower = report.policy.min === null ? null : `min ${report.policy.min}`;
+    const upper = report.policy.max === null ? null : `max ${report.policy.max}`;
+    return [lower, upper].filter((part) => part !== null).join(', ') + ` ${report.policy.unit}`;
+}
+function renderTextBudgetSummary(report, lang) {
+    const lines = [
+        t(lang, 'textBudget.title'),
+        `${t(lang, 'scriptPack.label.script')}: ${TEXT_BUDGET_SCRIPT_REF}`,
+        `${t(lang, 'label.status')}: ${report.status}`,
+        `${t(lang, 'textBudget.label.budget')}: ${renderBudget(report)}`,
+        `${t(lang, 'textBudget.label.checkedTargets')}: ${report.metrics.length}`,
+        `${t(lang, 'textBudget.label.findings')}: ${report.findings.length}`,
+    ];
+    if (report.metrics.length > 0) {
+        lines.push(t(lang, 'textBudget.label.metrics'));
+        for (const metric of report.metrics) {
+            const pointer = metric.json_pointer === null ? '' : ` ${metric.json_pointer}`;
+            lines.push(`- ${metric.path}${pointer}: ${metric.value} ${metric.unit}`);
+        }
+    }
+    if (report.findings.length > 0) {
+        lines.push(t(lang, 'textBudget.label.findings'));
+        for (const finding of report.findings) {
+            lines.push(`- ${finding.path}: ${finding.code} (${finding.message})`);
+        }
+    }
+    if (report.issues.length > 0) {
+        lines.push(t(lang, 'textBudget.label.issues'), ...report.issues.map((issue) => `- ${issue}`));
+    }
+    if (report.findings.length === 0 && report.issues.length === 0) {
+        lines.push(t(lang, 'textBudget.clean'));
+    }
+    return lines.join('\n');
+}
+export function runCoreTextBudgetScript(args, reporter, lang = 'en') {
+    if (hasCliOptionToken(args, '--help', ['-h'])) {
+        reporter.stdout(getCoreTextBudgetHelp(lang));
+        return 0;
+    }
+    const options = parseTextBudgetOptions(args, lang);
+    if (options.error) {
+        printUsageError(reporter, options.error, 'mf script-pack run core/text-budget --help', getCoreTextBudgetHelp(lang), lang);
+        return 1;
+    }
+    const report = inspectTextBudget(resolveMustflowRoot(), {
+        paths: options.paths,
+        min: options.min,
+        max: options.max,
+        exact: options.exact,
+        unit: options.unit,
+        jsonPointer: options.jsonPointer,
+    });
+    if (options.json) {
+        reporter.stdout(JSON.stringify(report, null, 2));
+        return report.ok ? 0 : 1;
+    }
+    reporter.stdout(renderTextBudgetSummary(report, lang));
+    return report.ok ? 0 : 1;
+}

package/dist/core/change-verification.js

@@ -4,6 +4,7 @@ import { classifyVerificationCandidate, createVerificationPlan, } from './verifi
 import { createVerificationDecisionGraph, } from './verification-decision-graph.js';
 import { createVerificationSchedule, } from './verification-scheduler.js';
 import { createProjectTestSelectionPlan, } from './test-selection.js';
+import { createVerificationRiskAssessment, } from './risk-priced-evidence.js';
 export const CHANGE_VERIFICATION_SCHEMA_VERSION = '1';
 function uniqueSorted(values) {
     return [...new Set(values)].sort((left, right) => left.localeCompare(right));
@@ -328,6 +329,14 @@ export function createChangeVerificationReport(classificationReport, commandCont
     const gaps = requirements
         .map((requirement) => gapForRequirement(requirement, candidates))
         .filter((gap) => gap !== null);
+    const riskAssessment = createVerificationRiskAssessment({
+        classificationSummary: classificationReport.summary,
+        requirements,
+        candidates,
+        gaps,
+        commandContract,
+        selectedIntents: schedule.entries.map((entry) => entry.intent),
+    });
     return {
         schema_version: CHANGE_VERIFICATION_SCHEMA_VERSION,
         source: classificationReport.source,
@@ -336,6 +345,7 @@ export function createChangeVerificationReport(classificationReport, commandCont
         requirements,
         candidates,
         gaps,
+        risk_assessment: riskAssessment,
         schedule,
         decision_graph: createVerificationDecisionGraph(commandContract, requirements, candidates, gaps, schedule),
         test_selection: testSelectionPlan.report,

package/dist/core/completion-verdict.js

@@ -10,6 +10,7 @@ function createRiskEvidence(input) {
         receipt_binding: input.receiptBindingRiskCount ?? 0,
         stale_receipt: input.staleReceiptCount ?? 0,
         plan_mismatch: input.planMismatchCount ?? 0,
+        risk_priced_evidence: input.riskPricedEvidenceRiskCount ?? 0,
     };
 }
 function emptyReceiptBindingEvidence() {
@@ -158,6 +159,9 @@ function verifyStatus(input) {
     if ((input.externalEvidenceRiskCount ?? 0) > 0) {
         downgradeLimitations.push('external_evidence_requires_review');
     }
+    if ((input.riskPricedEvidenceRiskCount ?? 0) > 0) {
+        downgradeLimitations.push('risk_priced_evidence_requires_review');
+    }
     if (downgradeLimitations.length > 0) {
         return {
             status: 'partially_verified',
@@ -175,7 +179,9 @@ function verifyStatus(input) {
                                     ? 'stale_receipt_review_required'
                                     : (input.reproEvidenceRiskCount ?? 0) > 0
                                         ? 'repro_evidence_missing'
-                                        : 'external_evidence_review_required',
+                                        : (input.externalEvidenceRiskCount ?? 0) > 0
+                                            ? 'external_evidence_review_required'
+                                            : 'risk_priced_evidence_review_required',
             blockers: [],
             contradictions: [],
             limitations: downgradeLimitations,
@@ -230,6 +236,7 @@ export function createVerifyCompletionVerdict(input) {
             receipt_binding_risk_count: normalizedInput.receiptBindingRiskCount ?? 0,
             stale_receipt_count: normalizedInput.staleReceiptCount ?? 0,
             plan_mismatch_count: normalizedInput.planMismatchCount ?? 0,
+            risk_priced_evidence_risk_count: normalizedInput.riskPricedEvidenceRiskCount ?? 0,
             risks,
             receipt_binding: receiptBinding,
             latest_run_status: null,
@@ -269,6 +276,11 @@ export function createDashboardCompletionVerdict(input) {
         primaryReason = 'scope_diff_review_required';
         limitations.push('scope_diff_risk_requires_review');
     }
+    else if ((input.riskPricedEvidenceRiskCount ?? 0) > 0) {
+        status = 'partially_verified';
+        primaryReason = 'risk_priced_evidence_review_required';
+        limitations.push('risk_priced_evidence_requires_review');
+    }
     else if (input.gapCount > 0) {
         status = 'blocked';
         primaryReason = 'verification_gaps_present';
@@ -331,6 +343,7 @@ export function createDashboardCompletionVerdict(input) {
             receipt_binding_risk_count: input.receiptBindingRiskCount ?? 0,
             stale_receipt_count: input.staleReceiptCount ?? 0,
             plan_mismatch_count: input.planMismatchCount ?? 0,
+            risk_priced_evidence_risk_count: input.riskPricedEvidenceRiskCount ?? 0,
             risks,
             receipt_binding: receiptBinding,
             latest_run_status: input.latestRunStatus,

package/dist/core/complexity-budget.js

@@ -0,0 +1,206 @@
+export const COMPLEXITY_BUDGET_DEFAULTS = {
+    scoreBudget: 12,
+    maxConfigSurfaces: 2,
+    maxSchemaSurfaces: 2,
+    maxPathsPerRisk: 8,
+};
+const CHANGE_KIND_FAMILY_BY_KIND = {
+    documentation: 'documentation',
+    example: 'documentation',
+    translation: 'documentation',
+    workflow: 'workflow',
+    host_instruction: 'workflow',
+    installed_template: 'template',
+    package_metadata: 'release',
+    schema: 'contract',
+    test: 'test',
+    test_fixture: 'test',
+    implementation: 'implementation',
+    unknown: 'unknown',
+};
+const DEPENDENCY_SURFACE_FILENAMES = new Set([
+    'package.json',
+    'package-lock.json',
+    'pnpm-lock.yaml',
+    'bun.lock',
+    'bun.lockb',
+    'yarn.lock',
+    'Cargo.toml',
+    'Cargo.lock',
+    'go.mod',
+    'go.sum',
+    'pyproject.toml',
+    'pom.xml',
+    'build.gradle',
+    'deno.json',
+    'deno.jsonc',
+]);
+const CONFIG_SURFACE_FILENAMES = new Set(['Makefile', 'justfile', 'Dockerfile']);
+const CONFIG_FILE_PATTERN = /(?:config|rc)\.(?:cjs|cts|js|json|mjs|mts|toml|ts|yaml|yml)$/u;
+const HELPER_FILE_PATTERN = /.*(?:helper|helpers|util|utils|manager|common|misc).*\.(?:cjs|cts|go|java|js|jsx|kt|mjs|mts|php|ps1|py|rb|rs|swift|ts|tsx)$/u;
+const REQUIREMENTS_FILE_PATTERN = /^requirements(?:-[^/]*)?\.txt$/u;
+const TSCONFIG_FILE_PATTERN = /^tsconfig[^/]*\.json$/u;
+function uniqueSorted(values) {
+    return [...new Set(values)].sort((left, right) => left.localeCompare(right));
+}
+function changeKindFamily(kind) {
+    return CHANGE_KIND_FAMILY_BY_KIND[kind] ?? kind;
+}
+function baseName(file) {
+    const slashIndex = file.lastIndexOf('/');
+    return slashIndex === -1 ? file : file.slice(slashIndex + 1);
+}
+function isDependencySurface(file) {
+    const name = baseName(file);
+    return DEPENDENCY_SURFACE_FILENAMES.has(name) || REQUIREMENTS_FILE_PATTERN.test(name);
+}
+function isConfigurationSurface(file) {
+    const name = baseName(file);
+    return (file.startsWith('.github/') ||
+        file.startsWith('.mustflow/config/') ||
+        CONFIG_SURFACE_FILENAMES.has(name) ||
+        CONFIG_FILE_PATTERN.test(name) ||
+        TSCONFIG_FILE_PATTERN.test(name));
+}
+function isHelperContainer(file) {
+    return HELPER_FILE_PATTERN.test(baseName(file));
+}
+function isSchemaSurface(file) {
+    return file.startsWith('schemas/') && file.endsWith('.schema.json');
+}
+function matchingPaths(files, predicate) {
+    return files.filter(predicate);
+}
+function firstPaths(paths) {
+    return paths.slice(0, COMPLEXITY_BUDGET_DEFAULTS.maxPathsPerRisk);
+}
+function metric(name, value, weight) {
+    return {
+        name,
+        value,
+        weight,
+        weighted_score: value * weight,
+    };
+}
+function scoreMetrics(input) {
+    const families = uniqueSorted(input.summary.changeKinds.map(changeKindFamily));
+    const dependencySurfaces = matchingPaths(input.files, isDependencySurface);
+    const configSurfaces = matchingPaths(input.files, isConfigurationSurface);
+    const helperContainers = matchingPaths(input.files, isHelperContainer);
+    const schemaSurfaces = matchingPaths(input.files, isSchemaSurface);
+    return [
+        metric('changed_files', input.summary.fileCount, 1),
+        metric('public_surfaces', input.summary.publicSurfaceCount, 2),
+        metric('change_kind_families_beyond_one', Math.max(0, families.length - 1), 2),
+        metric('dependency_surfaces', dependencySurfaces.length, 5),
+        metric('configuration_surfaces', configSurfaces.length, 3),
+        metric('helper_containers', helperContainers.length, 3),
+        metric('schema_surfaces', schemaSurfaces.length, 2),
+    ];
+}
+function risk(input) {
+    return {
+        code: input.code,
+        severity: 'warning',
+        detail: input.detail,
+        count: input.count,
+        limit: input.limit,
+        paths: firstPaths(input.paths),
+    };
+}
+function createComplexityBudgetRisks(input, score) {
+    const dependencySurfaces = matchingPaths(input.files, isDependencySurface);
+    const configSurfaces = matchingPaths(input.files, isConfigurationSurface);
+    const helperContainers = matchingPaths(input.files, isHelperContainer);
+    const schemaSurfaces = matchingPaths(input.files, isSchemaSurface);
+    const risks = [];
+    if (score > COMPLEXITY_BUDGET_DEFAULTS.scoreBudget) {
+        risks.push(risk({
+            code: 'complexity_score_budget_exceeded',
+            detail: `Complexity score ${score} exceeds the review budget of ${COMPLEXITY_BUDGET_DEFAULTS.scoreBudget}.`,
+            count: score,
+            limit: COMPLEXITY_BUDGET_DEFAULTS.scoreBudget,
+            paths: input.files,
+        }));
+    }
+    if (dependencySurfaces.length > 0) {
+        risks.push(risk({
+            code: 'dependency_surface_requires_justification',
+            detail: [
+                'Dependency or package manifest changes add operational cost;',
+                'justify the dependency boundary and rollback path.',
+            ].join(' '),
+            count: dependencySurfaces.length,
+            limit: 0,
+            paths: dependencySurfaces,
+        }));
+    }
+    if (helperContainers.length > 0) {
+        risks.push(risk({
+            code: 'helper_container_requires_justification',
+            detail: [
+                'Helper, util, common, manager, or misc files tend to hide broad abstractions;',
+                'justify why the new surface reduces net complexity.',
+            ].join(' '),
+            count: helperContainers.length,
+            limit: 0,
+            paths: helperContainers,
+        }));
+    }
+    if (configSurfaces.length > COMPLEXITY_BUDGET_DEFAULTS.maxConfigSurfaces) {
+        risks.push(risk({
+            code: 'configuration_surface_budget_exceeded',
+            detail: [
+                `Configuration surface count ${configSurfaces.length}`,
+                `exceeds the review budget of ${COMPLEXITY_BUDGET_DEFAULTS.maxConfigSurfaces}.`,
+            ].join(' '),
+            count: configSurfaces.length,
+            limit: COMPLEXITY_BUDGET_DEFAULTS.maxConfigSurfaces,
+            paths: configSurfaces,
+        }));
+    }
+    if (schemaSurfaces.length > COMPLEXITY_BUDGET_DEFAULTS.maxSchemaSurfaces) {
+        risks.push(risk({
+            code: 'schema_surface_budget_exceeded',
+            detail: [
+                `Schema surface count ${schemaSurfaces.length}`,
+                `exceeds the review budget of ${COMPLEXITY_BUDGET_DEFAULTS.maxSchemaSurfaces}.`,
+            ].join(' '),
+            count: schemaSurfaces.length,
+            limit: COMPLEXITY_BUDGET_DEFAULTS.maxSchemaSurfaces,
+            paths: schemaSurfaces,
+        }));
+    }
+    return risks;
+}
+function reviewPrompts(risks) {
+    if (risks.length === 0) {
+        return [];
+    }
+    return [
+        'Explain why this added complexity is necessary for the requested outcome.',
+        'Name the simpler alternative that was rejected and why it is not enough.',
+        'Identify the rollback or removal path if the added surface proves unnecessary.',
+    ];
+}
+export function createComplexityBudgetReport(input) {
+    const metrics = scoreMetrics(input);
+    const score = metrics.reduce((total, entry) => total + entry.weighted_score, 0);
+    const risks = createComplexityBudgetRisks(input, score);
+    return {
+        schema_version: '1',
+        source: 'change_classification',
+        status: risks.length > 0 ? 'review_required' : 'within_budget',
+        score,
+        budget: COMPLEXITY_BUDGET_DEFAULTS.scoreBudget,
+        metrics,
+        risks,
+        review_prompts: reviewPrompts(risks),
+    };
+}
+export function createComplexityBudgetReportFromVerification(report) {
+    return createComplexityBudgetReport({
+        files: report.files,
+        summary: report.classification_summary,
+    });
+}

package/dist/core/conflict-ledger.js

@@ -0,0 +1,122 @@
+import { createHash } from 'node:crypto';
+function hashConflictIdentity(value) {
+    return `conflict:${createHash('sha256').update(JSON.stringify(value)).digest('hex').slice(0, 16)}`;
+}
+function uniqueSorted(values) {
+    return [...new Set([...values].filter((value) => typeof value === 'string' && value.length > 0))].sort((left, right) => left.localeCompare(right));
+}
+function remainingRiskSeverity(severity) {
+    if (severity === 'critical') {
+        return 'critical';
+    }
+    if (severity === 'high' || severity === 'error') {
+        return 'error';
+    }
+    if (severity === 'medium' || severity === 'warning') {
+        return 'warning';
+    }
+    return 'info';
+}
+function createConflictItem(input) {
+    return {
+        id: hashConflictIdentity({
+            kind: input.kind,
+            summary: input.summary,
+            detail: input.detail,
+            sources: input.sources,
+        }),
+        status: 'open',
+        owner: 'user_or_maintainer',
+        expires_at: null,
+        ...input,
+    };
+}
+function verdictItem(kind, key) {
+    const contradiction = kind === 'contradiction';
+    return createConflictItem({
+        kind,
+        severity: contradiction ? 'critical' : 'error',
+        summary: key,
+        detail: contradiction
+            ? `Completion evidence is contradicted by ${key}.`
+            : `Completion is blocked by ${key}.`,
+        sources: [
+            {
+                kind: 'completion_verdict',
+                authority: 'verdict',
+                key,
+                paths: [],
+                surfaces: [],
+            },
+        ],
+        affected_paths: [],
+        affected_surfaces: [],
+        blocks_completion: true,
+        resolution: contradiction
+            ? 'Resolve the contradictory evidence and rerun verification before claiming completion.'
+            : 'Resolve the blocker and provide fresh verification evidence before claiming completion.',
+    });
+}
+function gapItem(gap) {
+    const key = gap.reason ?? gap.intent ?? gap.status ?? 'verification_gap';
+    return createConflictItem({
+        kind: 'verification_gap',
+        severity: 'error',
+        summary: key,
+        detail: gap.detail ?? 'Verification coverage is missing for this requirement.',
+        sources: [
+            {
+                kind: 'verification_gap',
+                authority: 'verification_plan',
+                key,
+                paths: uniqueSorted(gap.files),
+                surfaces: uniqueSorted(gap.surfaces),
+            },
+        ],
+        affected_paths: uniqueSorted(gap.files),
+        affected_surfaces: uniqueSorted(gap.surfaces),
+        blocks_completion: true,
+        resolution: 'Add or run an allowed verification intent that covers this gap, then refresh the evidence model.',
+    });
+}
+function riskItem(risk) {
+    const severity = remainingRiskSeverity(risk.severity);
+    return createConflictItem({
+        kind: 'remaining_risk',
+        severity,
+        summary: risk.code,
+        detail: risk.detail,
+        sources: [
+            {
+                kind: 'remaining_risk',
+                authority: 'evidence_model',
+                key: risk.code,
+                paths: [],
+                surfaces: [],
+            },
+        ],
+        affected_paths: [],
+        affected_surfaces: [],
+        blocks_completion: severity === 'error' || severity === 'critical',
+        resolution: 'Review the remaining risk and attach stronger evidence or an explicit acceptance decision.',
+    });
+}
+export function createConflictLedger(input) {
+    const items = [
+        ...input.verdict.blockers.map((blocker) => verdictItem('blocker', blocker)),
+        ...input.verdict.contradictions.map((contradiction) => verdictItem('contradiction', contradiction)),
+        ...input.gaps.map(gapItem),
+        ...input.remainingRisks.map(riskItem),
+    ];
+    const blockingCount = items.filter((item) => item.blocks_completion).length;
+    const contradictionCount = items.filter((item) => item.kind === 'contradiction').length;
+    return {
+        schema_version: '1',
+        source: 'verification_evidence_model',
+        status: items.length > 0 ? 'open' : 'clear',
+        item_count: items.length,
+        blocking_count: blockingCount,
+        contradiction_count: contradictionCount,
+        items,
+    };
+}