mustflow 1.15.97

package/dist/core/contract-lint.js

@@ -0,0 +1,110 @@
+import { COMMAND_LIFECYCLES, COMMAND_RUN_POLICIES, LONG_RUNNING_LIFECYCLES, isRecord, readPositiveInteger, readString, } from './config-loading.js';
+import { evaluateCommandIntentEligibility } from './command-intent-eligibility.js';
+import { commandIntentHasBlockedShellBackgroundPattern, commandIntentHasCommandSource, commandIntentNameIsSafe, } from './command-contract-rules.js';
+const CONTRACT_LINT_SOURCE_FILES = ['.mustflow/config/commands.toml', '.mustflow/docs/agent-workflow.md', 'AGENTS.md'];
+function readBoolean(intent, key) {
+    const value = intent[key];
+    return typeof value === 'boolean' ? value : null;
+}
+function successExitCodesAreValid(intent) {
+    const value = intent.success_exit_codes;
+    return value === undefined || (Array.isArray(value) && value.every((entry) => Number.isInteger(entry)));
+}
+function writesAreValid(intent) {
+    const value = intent.writes;
+    return value === undefined || (Array.isArray(value) && value.every((entry) => typeof entry === 'string'));
+}
+function pushIssue(issues, severity, code, intent, message) {
+    issues.push({ severity, code, intent, message });
+}
+function configuredIntentIsRunnable(intent) {
+    return evaluateCommandIntentEligibility('summary', intent).ok;
+}
+function lintIntent(name, value, issues) {
+    if (!commandIntentNameIsSafe(name)) {
+        pushIssue(issues, 'error', 'unsafe_intent_name', name, `Intent ${name} name must contain only letters, numbers, underscores, and hyphens.`);
+    }
+    if (!isRecord(value)) {
+        pushIssue(issues, 'error', 'intent_not_table', name, `Intent ${name} must be a TOML table.`);
+        return null;
+    }
+    const status = readString(value, 'status');
+    if (!status || !['configured', 'manual_only', 'unknown'].includes(status)) {
+        pushIssue(issues, 'error', 'invalid_status', name, `Intent ${name} must set status to configured, manual_only, or unknown.`);
+        return value;
+    }
+    if (status === 'unknown') {
+        pushIssue(issues, 'warning', 'intent_unknown', name, `Intent ${name} is declared but has no configured command yet.`);
+    }
+    if (status === 'manual_only') {
+        pushIssue(issues, 'warning', 'intent_manual_only', name, `Intent ${name} requires explicit manual handling.`);
+    }
+    if (status !== 'configured') {
+        return value;
+    }
+    const lifecycle = readString(value, 'lifecycle');
+    const runPolicy = readString(value, 'run_policy');
+    if (!lifecycle || !COMMAND_LIFECYCLES.has(lifecycle)) {
+        pushIssue(issues, 'error', 'invalid_lifecycle', name, `Configured intent ${name} must define a valid lifecycle.`);
+    }
+    if (!runPolicy || !COMMAND_RUN_POLICIES.has(runPolicy)) {
+        pushIssue(issues, 'error', 'invalid_run_policy', name, `Configured intent ${name} must define a valid run_policy.`);
+    }
+    if (lifecycle === 'oneshot' && readPositiveInteger(value, 'timeout_seconds') === undefined) {
+        pushIssue(issues, 'error', 'oneshot_missing_timeout', name, `Oneshot intent ${name} must define timeout_seconds.`);
+    }
+    if (lifecycle === 'oneshot' && readString(value, 'stdin') !== 'closed') {
+        pushIssue(issues, 'error', 'oneshot_stdin_not_closed', name, `Oneshot intent ${name} must set stdin to closed.`);
+    }
+    if (lifecycle && LONG_RUNNING_LIFECYCLES.has(lifecycle) && runPolicy === 'agent_allowed') {
+        pushIssue(issues, 'error', 'long_running_agent_allowed', name, `Long-running intent ${name} must not be agent_allowed.`);
+    }
+    if (!commandIntentHasCommandSource(value)) {
+        pushIssue(issues, 'error', 'executable_source_missing', name, `Configured intent ${name} must define argv or shell cmd.`);
+    }
+    if (commandIntentHasBlockedShellBackgroundPattern(value)) {
+        pushIssue(issues, 'error', 'shell_background_pattern', name, `Shell intent ${name} contains a blocked long-running or background pattern.`);
+    }
+    if (!successExitCodesAreValid(value)) {
+        pushIssue(issues, 'error', 'invalid_success_exit_codes', name, `Intent ${name} success_exit_codes must be an integer array.`);
+    }
+    if (!writesAreValid(value)) {
+        pushIssue(issues, 'error', 'invalid_writes', name, `Intent ${name} writes must be a string array.`);
+    }
+    if (readBoolean(value, 'network') === null && Object.hasOwn(value, 'network')) {
+        pushIssue(issues, 'error', 'invalid_network', name, `Intent ${name} network must be a boolean.`);
+    }
+    if (readBoolean(value, 'destructive') === null && Object.hasOwn(value, 'destructive')) {
+        pushIssue(issues, 'error', 'invalid_destructive', name, `Intent ${name} destructive must be a boolean.`);
+    }
+    return value;
+}
+function getStatus(errors, warnings) {
+    if (errors > 0) {
+        return 'failed';
+    }
+    return warnings > 0 ? 'warning' : 'passed';
+}
+export function lintCommandContract(contract) {
+    const issues = [];
+    const intentEntries = Object.entries(contract.intents);
+    const intentTables = intentEntries
+        .map(([name, value]) => lintIntent(name, value, issues))
+        .filter((intent) => intent !== null);
+    const errors = issues.filter((issue) => issue.severity === 'error').length;
+    const warnings = issues.length - errors;
+    return {
+        status: getStatus(errors, warnings),
+        summary: {
+            totalIntents: intentEntries.length,
+            configured: intentTables.filter((intent) => readString(intent, 'status') === 'configured').length,
+            runnable: intentTables.filter(configuredIntentIsRunnable).length,
+            manualOnly: intentTables.filter((intent) => readString(intent, 'status') === 'manual_only').length,
+            unknown: intentTables.filter((intent) => readString(intent, 'status') === 'unknown').length,
+            errors,
+            warnings,
+        },
+        issues,
+        sourceFiles: CONTRACT_LINT_SOURCE_FILES,
+    };
+}

package/dist/core/contract-models.js

@@ -0,0 +1,53 @@
+export const CONTRACT_MODEL_DEFINITIONS = [
+    {
+        id: 'changes',
+        filePath: '.mustflow/config/changes.toml',
+        status: 'candidate',
+        installByDefault: false,
+        purpose: 'Describe changed-file classes that can feed verification and surface planning.',
+        authority: 'planning',
+    },
+    {
+        id: 'validations',
+        filePath: '.mustflow/config/validations.toml',
+        status: 'candidate',
+        installByDefault: false,
+        purpose: 'Describe validation reasons and their relationship to configured command intents.',
+        authority: 'planning',
+    },
+    {
+        id: 'surfaces',
+        filePath: '.mustflow/config/surfaces.toml',
+        status: 'candidate',
+        installByDefault: false,
+        purpose: 'Describe public and installed surfaces that may need drift checks after changes.',
+        authority: 'planning',
+    },
+    {
+        id: 'artifacts',
+        filePath: '.mustflow/config/artifacts.toml',
+        status: 'candidate',
+        installByDefault: false,
+        purpose: 'Describe generated or packaged artifacts that need inclusion and freshness checks.',
+        authority: 'planning',
+    },
+    {
+        id: 'policy',
+        filePath: '.mustflow/config/policy.toml',
+        status: 'deferred',
+        installByDefault: false,
+        purpose: 'Reserved for future cross-cutting policy once smaller contract files have settled.',
+        authority: 'policy',
+    },
+];
+export function getContractModelDefinitions() {
+    return CONTRACT_MODEL_DEFINITIONS;
+}
+export function getCandidateContractModelDefinitions() {
+    return CONTRACT_MODEL_DEFINITIONS.filter((model) => model.status === 'candidate');
+}
+export function getNonInstalledContractConfigPaths() {
+    return CONTRACT_MODEL_DEFINITIONS
+        .filter((model) => !model.installByDefault)
+        .map((model) => model.filePath);
+}

package/dist/core/dashboard-verification.js

@@ -0,0 +1,132 @@
+import { createChangeClassificationReport } from './change-classification.js';
+import { createChangeVerificationReport, } from './change-verification.js';
+export const DASHBOARD_VERIFICATION_MAX_FILE_MATCHES = 8;
+function toPosixChangedFiles(changedFiles, manifestChangedFiles, manifestMissingFiles) {
+    return [
+        ...new Set([...changedFiles, ...manifestChangedFiles, ...manifestMissingFiles].map((filePath) => filePath.replaceAll('\\', '/'))),
+    ].sort((left, right) => left.localeCompare(right));
+}
+function uniqueLimitedFiles(left, right) {
+    return [...new Set([...left, ...right])].slice(0, DASHBOARD_VERIFICATION_MAX_FILE_MATCHES);
+}
+function verificationReasonKey(requirement) {
+    if (requirement.reason === 'mustflow_config_change' || requirement.reason === 'mustflow_docs_change') {
+        return 'dashboard.verification.reason.mustflow';
+    }
+    if (requirement.reason === 'docs_change' || requirement.reason === 'copy_change' || requirement.reason === 'i18n_change') {
+        return 'dashboard.verification.reason.docs';
+    }
+    if (requirement.reason === 'package_metadata_change' ||
+        requirement.reason === 'template_version_change' ||
+        requirement.reason === 'packaging_change' ||
+        requirement.reason === 'release_risk') {
+        return 'dashboard.verification.reason.release';
+    }
+    if (requirement.reason === 'code_change' ||
+        requirement.reason === 'test_change' ||
+        requirement.reason === 'public_api_change') {
+        return 'dashboard.verification.reason.code';
+    }
+    return 'dashboard.verification.reason.fallback';
+}
+function requirementFiles(requirement, allChangedFiles) {
+    return (requirement.files.length > 0 ? requirement.files : allChangedFiles).slice(0, DASHBOARD_VERIFICATION_MAX_FILE_MATCHES);
+}
+function addDashboardRecommendation(recommendations, commandByName, intent, reasonKey, files) {
+    const existingIndex = recommendations.findIndex((item) => item.intent === intent);
+    if (existingIndex >= 0) {
+        const existing = recommendations[existingIndex];
+        recommendations[existingIndex] = {
+            ...existing,
+            files: uniqueLimitedFiles(existing.files, files),
+        };
+        return;
+    }
+    const command = commandByName.get(intent);
+    recommendations.push({
+        intent,
+        command: `mf run ${intent}`,
+        reason_key: reasonKey,
+        files: files.slice(0, DASHBOARD_VERIFICATION_MAX_FILE_MATCHES),
+        runnable: command?.runnable ?? false,
+    });
+}
+function addSkippedCandidate(skipped, candidate) {
+    if (!candidate.intent || skipped.some((item) => item.intent === candidate.intent)) {
+        return;
+    }
+    skipped.push({
+        intent: candidate.intent,
+        reason_key: 'dashboard.verification.skip.notRunnable',
+    });
+}
+function createEmptyDashboardVerificationSnapshot(changedFiles) {
+    return {
+        changed_files: changedFiles,
+        surfaces: [],
+        recommendations: [],
+        skipped: [],
+        schedule: {
+            runner: 'serial_mf_run_receipts',
+            batches: [],
+            entries: [],
+            notes: [],
+        },
+    };
+}
+export function createDashboardVerificationSnapshot(projectRoot, rawCommandContract, commandIntents, changedFiles, manifestChangedFiles, manifestMissingFiles) {
+    const allChangedFiles = toPosixChangedFiles(changedFiles, manifestChangedFiles, manifestMissingFiles);
+    if (!rawCommandContract || allChangedFiles.length === 0) {
+        return createEmptyDashboardVerificationSnapshot(allChangedFiles);
+    }
+    const classificationReport = createChangeClassificationReport('changed', allChangedFiles);
+    const verificationReport = createChangeVerificationReport(classificationReport, rawCommandContract, projectRoot);
+    const commandByName = new Map(commandIntents.map((intent) => [intent.name, intent]));
+    const recommendations = [];
+    const skipped = [];
+    const requirementByReason = new Map(verificationReport.requirements.map((requirement) => [requirement.reason, requirement]));
+    for (const candidate of verificationReport.candidates) {
+        const requirement = requirementByReason.get(candidate.reason);
+        if (!requirement) {
+            continue;
+        }
+        if (candidate.status === 'runnable' && candidate.intent) {
+            addDashboardRecommendation(recommendations, commandByName, candidate.intent, verificationReasonKey(requirement), requirementFiles(requirement, allChangedFiles));
+            continue;
+        }
+        addSkippedCandidate(skipped, candidate);
+    }
+    return {
+        changed_files: verificationReport.files,
+        surfaces: [...new Set(verificationReport.requirements.flatMap((requirement) => requirement.surfaces))].sort((left, right) => left.localeCompare(right)),
+        recommendations,
+        skipped,
+        schedule: {
+            runner: verificationReport.schedule.runner,
+            batches: verificationReport.schedule.batches.map((batch) => ({
+                index: batch.index,
+                intents: batch.intents,
+                commands: batch.intents.map((intent) => `mf run ${intent}`),
+                locks: batch.locks,
+            })),
+            entries: verificationReport.schedule.entries.map((entry) => ({
+                intent: entry.intent,
+                command: `mf run ${entry.intent}`,
+                locks: entry.locks,
+                effects: entry.effects.map((effect) => ({
+                    access: effect.access,
+                    mode: effect.mode,
+                    path: effect.path,
+                    lock: effect.lock,
+                    concurrency: effect.concurrency,
+                })),
+                conflicts: entry.conflicts.map((conflict) => ({
+                    intent: conflict.conflictsWith,
+                    lock: conflict.lock,
+                    detail: conflict.detail,
+                })),
+            })),
+            notes: verificationReport.schedule.notes,
+        },
+    };
+}

package/dist/core/doc-review-triage.js

@@ -0,0 +1,92 @@
+const P0_EXACT_PATHS = new Set([
+    'README.md',
+    'CHANGELOG.md',
+    'AGENTS.md',
+    '.mustflow/docs/agent-workflow.md',
+    '.mustflow/skills/INDEX.md',
+]);
+const AUTHORITY_OR_SECURITY_SKILLS = new Set([
+    'contract-sync-check',
+    'external-prompt-injection-defense',
+    'instruction-conflict-scope-check',
+    'migration-safety-check',
+    'multi-agent-work-coordination',
+    'requirement-regression-guard',
+    'security-privacy-review',
+    'security-regression-tests',
+    'test-maintenance',
+]);
+function normalizePath(value) {
+    return value.replace(/\\/g, '/').replace(/^\.\//u, '');
+}
+function isDefaultTemplateEnglishSource(path) {
+    return path.startsWith('templates/default/locales/en/') || path.startsWith('templates/default/common/');
+}
+function isEnglishCommandDoc(path) {
+    return /^docs-site\/src\/content\/docs\/en\/commands\/[^/]+\.md$/u.test(path);
+}
+function isAuthorityOrSecuritySkill(path) {
+    const match = /^\.mustflow\/skills\/([^/]+)\/SKILL\.md$/u.exec(path);
+    return Boolean(match && AUTHORITY_OR_SECURITY_SKILLS.has(match[1]));
+}
+function isTranslationReviewDebt(input, path) {
+    if (/^docs-site\/src\/content\/docs\/(?!en\/)[^/]+\//u.test(path) ||
+        /^templates\/default\/locales\/(?!en\/)[^/]+\//u.test(path)) {
+        return true;
+    }
+    const text = `${input.origin ?? ''} ${input.reason ?? ''}`.toLowerCase();
+    return text.includes('translation') || text.includes('stale') || text.includes('needs_review');
+}
+function isTestFixture(path) {
+    return path.startsWith('tests/fixtures/') || path.includes('/fixtures/') || path.includes('/__fixtures__/');
+}
+export function triageDocReview(input) {
+    const path = normalizePath(input.path);
+    if (P0_EXACT_PATHS.has(path)) {
+        return {
+            review_priority: 'P0',
+            release_blocking: input.status !== 'approved',
+            triage_reason: 'release_contract',
+        };
+    }
+    if (isAuthorityOrSecuritySkill(path)) {
+        return {
+            review_priority: 'P0',
+            release_blocking: input.status !== 'approved',
+            triage_reason: 'authority_or_security_skill',
+        };
+    }
+    if (isDefaultTemplateEnglishSource(path)) {
+        return {
+            review_priority: 'P0',
+            release_blocking: input.status !== 'approved',
+            triage_reason: 'default_template_source',
+        };
+    }
+    if (isEnglishCommandDoc(path)) {
+        return {
+            review_priority: 'P0',
+            release_blocking: input.status !== 'approved',
+            triage_reason: 'english_command_doc',
+        };
+    }
+    if (isTestFixture(path)) {
+        return {
+            review_priority: 'P2',
+            release_blocking: false,
+            triage_reason: 'test_fixture',
+        };
+    }
+    if (isTranslationReviewDebt(input, path)) {
+        return {
+            review_priority: 'P2',
+            release_blocking: false,
+            triage_reason: 'translation_review_debt',
+        };
+    }
+    return {
+        review_priority: 'P1',
+        release_blocking: false,
+        triage_reason: 'user_visible_doc',
+    };
+}

package/dist/core/line-endings.js

@@ -0,0 +1,144 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+const GITATTRIBUTES_PATH = '.gitattributes';
+function toPosixPath(value) {
+    return value.split(path.sep).join('/');
+}
+function hasLfPolicy(projectRoot) {
+    const attributesPath = path.join(projectRoot, GITATTRIBUTES_PATH);
+    if (!existsSync(attributesPath)) {
+        return false;
+    }
+    const content = readFileSync(attributesPath, 'utf8');
+    return /^\*\s+.*(?:^|\s)eol=lf(?:\s|$)/imu.test(content);
+}
+function gitList(projectRoot, args) {
+    const result = spawnSync('git', [...args, '-z'], {
+        cwd: projectRoot,
+        encoding: 'buffer',
+        stdio: ['ignore', 'pipe', 'pipe'],
+        windowsHide: true,
+    });
+    if (result.status !== 0) {
+        return null;
+    }
+    return result.stdout
+        .toString('utf8')
+        .split('\0')
+        .map((entry) => entry.trim())
+        .filter((entry) => entry.length > 0)
+        .sort((left, right) => left.localeCompare(right));
+}
+function listGitTrackedFiles(projectRoot) {
+    return gitList(projectRoot, ['ls-files']);
+}
+function listGitChangedFiles(projectRoot) {
+    const changedLists = [
+        gitList(projectRoot, ['diff', '--name-only', '--diff-filter=ACMR']),
+        gitList(projectRoot, ['diff', '--cached', '--name-only', '--diff-filter=ACMR']),
+        gitList(projectRoot, ['ls-files', '--others', '--exclude-standard']),
+    ];
+    if (changedLists.some((list) => list === null)) {
+        return null;
+    }
+    return [...new Set(changedLists.flatMap((list) => list ?? []))].sort((left, right) => left.localeCompare(right));
+}
+function detectLineEnding(buffer) {
+    if (buffer.includes(0)) {
+        return 'binary';
+    }
+    let lfCount = 0;
+    let crlfCount = 0;
+    for (let index = 0; index < buffer.length; index += 1) {
+        if (buffer[index] !== 0x0a) {
+            continue;
+        }
+        lfCount += 1;
+        if (index > 0 && buffer[index - 1] === 0x0d) {
+            crlfCount += 1;
+        }
+    }
+    if (lfCount === 0) {
+        return 'none';
+    }
+    if (crlfCount === 0) {
+        return 'lf';
+    }
+    return crlfCount === lfCount ? 'crlf' : 'mixed';
+}
+function normalizeLf(buffer) {
+    const bytes = [];
+    for (let index = 0; index < buffer.length; index += 1) {
+        const byte = buffer[index];
+        if (byte === 0x0d) {
+            bytes.push(0x0a);
+            if (buffer[index + 1] === 0x0a) {
+                index += 1;
+            }
+            continue;
+        }
+        bytes.push(byte);
+    }
+    return Buffer.from(bytes);
+}
+export function inspectLineEndings(projectRoot, mode, options = {}) {
+    const root = path.resolve(projectRoot);
+    const policy = hasLfPolicy(root) ? 'lf' : 'unknown';
+    const policyPath = policy === 'lf' ? GITATTRIBUTES_PATH : null;
+    const scope = options.scope ?? 'changed';
+    const candidateFiles = scope === 'tracked' ? listGitTrackedFiles(root) : listGitChangedFiles(root);
+    const issues = [];
+    const nonCompliantFiles = [];
+    const changedFiles = [];
+    const apply = options.apply === true;
+    if (!candidateFiles) {
+        issues.push('Git tracked files could not be listed. Run this command inside a Git working tree.');
+    }
+    if (policy !== 'lf') {
+        issues.push('No repository LF policy was detected in .gitattributes.');
+    }
+    if (mode === 'normalize' && apply && policy !== 'lf') {
+        issues.push('Refused to normalize without an explicit .gitattributes LF policy.');
+    }
+    const canApply = mode === 'normalize' && apply && policy === 'lf' && candidateFiles !== null;
+    for (const relativePath of candidateFiles ?? []) {
+        const absolutePath = path.join(root, ...relativePath.split('/'));
+        if (!existsSync(absolutePath)) {
+            continue;
+        }
+        const buffer = readFileSync(absolutePath);
+        const lineEnding = detectLineEnding(buffer);
+        const wouldChange = policy === 'lf' && (lineEnding === 'crlf' || lineEnding === 'mixed');
+        if (!wouldChange) {
+            continue;
+        }
+        if (canApply) {
+            writeFileSync(absolutePath, normalizeLf(buffer));
+            changedFiles.push(toPosixPath(relativePath));
+        }
+        nonCompliantFiles.push({
+            path: toPosixPath(relativePath),
+            lineEnding,
+            wouldChange,
+            changed: canApply,
+        });
+    }
+    return {
+        schema_version: '1',
+        command: 'line-endings',
+        mode,
+        scope,
+        ok: issues.length === 0 && (canApply || nonCompliantFiles.length === 0),
+        mustflow_root: root,
+        policy,
+        policy_path: policyPath,
+        git_tracked: candidateFiles !== null,
+        checked_files: candidateFiles?.length ?? 0,
+        non_compliant_files: nonCompliantFiles,
+        changed_files: changedFiles,
+        dry_run: mode === 'normalize' && !apply,
+        wrote_files: changedFiles.length > 0,
+        issues,
+    };
+}

package/dist/core/public-json-contracts.js

@@ -0,0 +1,112 @@
+const PUBLIC_JSON_SCHEMA_CONTRACTS = [
+    {
+        id: 'doctor-report',
+        schemaFile: 'doctor-report.schema.json',
+        producer: 'mf doctor --json',
+        packaged: true,
+        documented: true,
+        installedCommand: ['mf', 'doctor', '--json'],
+    },
+    {
+        id: 'context-report',
+        schemaFile: 'context-report.schema.json',
+        producer: 'mf context --json',
+        packaged: true,
+        documented: true,
+        installedCommand: ['mf', 'context', '--json'],
+    },
+    {
+        id: 'run-receipt',
+        schemaFile: 'run-receipt.schema.json',
+        producer: 'mf run <intent> --json',
+        packaged: true,
+        documented: true,
+        installedCommand: ['mf', 'run', 'mustflow_check', '--json'],
+    },
+    {
+        id: 'commands',
+        schemaFile: 'commands.schema.json',
+        producer: 'parsed .mustflow/config/commands.toml',
+        packaged: true,
+        documented: true,
+    },
+    {
+        id: 'contract-lint-report',
+        schemaFile: 'contract-lint-report.schema.json',
+        producer: 'mf contract-lint --json',
+        packaged: true,
+        documented: true,
+        installedCommand: ['mf', 'contract-lint', '--json'],
+    },
+    {
+        id: 'classify-report',
+        schemaFile: 'classify-report.schema.json',
+        producer: 'mf classify <path...> --json',
+        packaged: true,
+        documented: true,
+        installedCommand: ['mf', 'classify', 'README.md', '--json'],
+    },
+    {
+        id: 'impact-report',
+        schemaFile: 'impact-report.schema.json',
+        producer: 'mf impact <path...> --json',
+        packaged: true,
+        documented: true,
+        installedCommand: ['mf', 'impact', 'package.json', '--json'],
+    },
+    {
+        id: 'line-endings-report',
+        schemaFile: 'line-endings-report.schema.json',
+        producer: 'mf line-endings check --json',
+        packaged: true,
+        documented: true,
+        installedCommand: ['mf', 'line-endings', 'check', '--json'],
+        expectedExitCodes: [0, 1],
+    },
+    {
+        id: 'version-sources-report',
+        schemaFile: 'version-sources-report.schema.json',
+        producer: 'mf version-sources --json',
+        packaged: true,
+        documented: true,
+        installedCommand: ['mf', 'version-sources', '--json'],
+    },
+    {
+        id: 'docs-review-list',
+        schemaFile: 'docs-review-list.schema.json',
+        producer: 'mf docs review list --json',
+        packaged: true,
+        documented: true,
+        installedCommand: ['mf', 'docs', 'review', 'list', '--json'],
+    },
+    {
+        id: 'explain-report',
+        schemaFile: 'explain-report.schema.json',
+        producer: 'mf explain <topic> --json',
+        packaged: true,
+        documented: true,
+        installedCommand: ['mf', 'explain', 'authority', 'AGENTS.md', '--json'],
+    },
+    {
+        id: 'verify-report',
+        schemaFile: 'verify-report.schema.json',
+        producer: 'mf verify --reason <event> --json',
+        packaged: true,
+        documented: true,
+        installedCommand: ['mf', 'verify', '--reason', 'schema_verify', '--json'],
+    },
+    {
+        id: 'change-verification-report',
+        schemaFile: 'change-verification-report.schema.json',
+        producer: 'mf verify --reason <event> --plan-only --json',
+        packaged: true,
+        documented: true,
+        installedCommand: ['mf', 'verify', '--reason', 'schema_verify', '--plan-only', '--json'],
+    },
+];
+export function getPublicJsonSchemaContracts() {
+    return PUBLIC_JSON_SCHEMA_CONTRACTS;
+}
+export function getPublicJsonSchemaFiles() {
+    return PUBLIC_JSON_SCHEMA_CONTRACTS.map((contract) => contract.schemaFile);
+}