mustflow 1.30.0 → 1.31.0

package/dist/core/change-classification.js

@@ -14,7 +14,8 @@ function surface(kind, category, isPublicSurface, validationReasons, affectedCon
         driftChecks,
     };
 }
-const UNKNOWN_SURFACE = surface('unclassified_path', 'unknown', false, [], [], 'not_applicable', []);
+const UNKNOWN_CHANGE_REASON = 'unknown_change';
+const UNKNOWN_SURFACE = surface('unclassified_path', 'unknown', false, [UNKNOWN_CHANGE_REASON], ['unclassified repository path'], 'not_applicable', ['classification rule coverage']);
 function rule(id, match, changeKinds, surfaceContract) {
     return {
         id,
@@ -80,7 +81,10 @@ export function listChangeClassificationRuleDescriptors() {
     }));
 }
 export function listChangeClassificationValidationReasons() {
-    return uniqueSorted(CHANGE_CLASSIFICATION_RULES.flatMap((classificationRule) => classificationRule.surface.validationReasons));
+    return uniqueSorted([
+        ...CHANGE_CLASSIFICATION_RULES.flatMap((classificationRule) => classificationRule.surface.validationReasons),
+        ...UNKNOWN_SURFACE.validationReasons,
+    ]);
 }
 export function createChangeClassificationReport(source, relativePaths) {
     const files = uniqueSorted(relativePaths.map(normalizeStatusPath).filter((filePath) => filePath.length > 0));

package/dist/core/change-verification.js

@@ -1,7 +1,9 @@
+import { isRecord, readStringArray } from './config-loading.js';
 import { CHANGE_CLASSIFICATION_SURFACE_AUTHORITY, createPathTarget, } from './surface-decision-model.js';
-import { createVerificationPlan, } from './verification-plan.js';
+import { classifyVerificationCandidate, createVerificationPlan, } from './verification-plan.js';
 import { createVerificationDecisionGraph, } from './verification-decision-graph.js';
 import { createVerificationSchedule, } from './verification-scheduler.js';
+import { createProjectTestSelectionPlan, } from './test-selection.js';
 export const CHANGE_VERIFICATION_SCHEMA_VERSION = '1';
 function uniqueSorted(values) {
     return [...new Set(values)].sort((left, right) => left.localeCompare(right));
@@ -9,6 +11,21 @@ function uniqueSorted(values) {
 function uniqueUpdatePolicies(values) {
     return uniqueSorted([...values].filter((value) => value !== 'not_applicable'));
 }
+const DECLARED_ESCALATION_SIGNALS = [
+    'public_api',
+    'release',
+    'package',
+    'packaging',
+    'security',
+    'selector',
+    'command contract',
+    'classifier',
+    'classification',
+    'verification planner',
+    'verification planning',
+    'machine-readable output contract',
+    'JSON schema',
+];
 function classificationsForReason(classificationReport, reason) {
     return classificationReport.classifications.filter((classification) => classification.surface.validationReasons.includes(reason));
 }
@@ -40,13 +57,209 @@ function createVerificationRequirement(classificationReport, reason) {
         source: 'change_classification',
     };
 }
-function toChangeVerificationCandidate(reason, candidate) {
+function candidateKey(reason, intent) {
+    return `${reason}\0${intent}`;
+}
+function readIntentRelationList(commandContract, intent, key) {
+    const rawIntent = commandContract.intents[intent];
+    if (!isRecord(rawIntent) || !isRecord(rawIntent.relations)) {
+        return [];
+    }
+    return readStringArray(rawIntent.relations, key) ?? [];
+}
+function readIntentSelectionList(commandContract, intent, key) {
+    const rawIntent = commandContract.intents[intent];
+    if (!isRecord(rawIntent) || !isRecord(rawIntent.selection)) {
+        return [];
+    }
+    return readStringArray(rawIntent.selection, key) ?? [];
+}
+function readIntentCostExpectedSeconds(commandContract, intent) {
+    const rawIntent = commandContract.intents[intent];
+    if (!isRecord(rawIntent) || !isRecord(rawIntent.cost)) {
+        return null;
+    }
+    const expectedSeconds = rawIntent.cost.expected_seconds;
+    return Number.isInteger(expectedSeconds) && Number(expectedSeconds) >= 0 ? Number(expectedSeconds) : null;
+}
+function intentCoverageSignature(commandContract, intent) {
+    const rawIntent = commandContract.intents[intent];
+    if (!isRecord(rawIntent) || !isRecord(rawIntent.covers)) {
+        return null;
+    }
+    const signature = {
+        contracts: uniqueSorted(readStringArray(rawIntent.covers, 'contracts') ?? []),
+        paths: uniqueSorted(readStringArray(rawIntent.covers, 'paths') ?? []),
+        reasons: uniqueSorted(readStringArray(rawIntent.covers, 'reasons') ?? []),
+        surfaces: uniqueSorted(readStringArray(rawIntent.covers, 'surfaces') ?? []),
+    };
+    if (signature.contracts.length === 0 &&
+        signature.paths.length === 0 &&
+        signature.reasons.length === 0 &&
+        signature.surfaces.length === 0) {
+        return null;
+    }
+    return JSON.stringify(signature);
+}
+function fallbackIntentsForCandidate(commandContract, candidate) {
+    if (candidate.intent.length === 0 || candidate.status === 'runnable') {
+        return [];
+    }
+    return uniqueSorted([
+        ...readIntentSelectionList(commandContract, candidate.intent, 'fallback_intents'),
+        ...readIntentSelectionList(commandContract, candidate.intent, 'escalate_to'),
+        ...readIntentRelationList(commandContract, candidate.intent, 'escalate_to'),
+    ]);
+}
+function escalationIntentsForCandidate(commandContract, candidate) {
+    if (candidate.intent.length === 0) {
+        return [];
+    }
+    return uniqueSorted([
+        ...readIntentSelectionList(commandContract, candidate.intent, 'escalate_to'),
+        ...readIntentRelationList(commandContract, candidate.intent, 'escalate_to'),
+    ]);
+}
+function expandCandidatesWithDeclaredFallbacks(commandContract, candidates) {
+    const hasRunnableCandidate = candidates.some((candidate) => candidate.status === 'runnable' && candidate.intent.length > 0);
+    if (hasRunnableCandidate) {
+        return candidates;
+    }
+    const existingIntents = new Set(candidates.map((candidate) => candidate.intent).filter((intent) => intent.length > 0));
+    const fallbackIntents = uniqueSorted(candidates.flatMap((candidate) => fallbackIntentsForCandidate(commandContract, candidate))).filter((intent) => !existingIntents.has(intent));
+    if (fallbackIntents.length === 0) {
+        return candidates;
+    }
+    return [
+        ...candidates,
+        ...fallbackIntents.map((intent) => {
+            const fallback = classifyVerificationCandidate(intent, commandContract.intents[intent]);
+            return {
+                ...fallback,
+                detail: fallback.status === 'runnable' ? 'Declared fallback for unavailable verification intent.' : fallback.detail,
+            };
+        }),
+    ];
+}
+function requirementNeedsDeclaredEscalation(requirement) {
+    if (requirement.surfaces.length > 1) {
+        return true;
+    }
+    const signalText = [
+        requirement.reason,
+        ...requirement.affectedContracts,
+        ...requirement.driftChecks,
+        ...requirement.surfaces,
+    ].join('\n').toLowerCase();
+    return DECLARED_ESCALATION_SIGNALS.some((signal) => signalText.includes(signal.toLowerCase()));
+}
+function expandCandidatesWithDeclaredEscalations(commandContract, requirement, candidates) {
+    if (!requirementNeedsDeclaredEscalation(requirement)) {
+        return candidates;
+    }
+    const existingIntents = new Set(candidates.map((candidate) => candidate.intent).filter((intent) => intent.length > 0));
+    const escalationIntents = uniqueSorted(candidates.flatMap((candidate) => escalationIntentsForCandidate(commandContract, candidate))).filter((intent) => !existingIntents.has(intent));
+    if (escalationIntents.length === 0) {
+        return candidates;
+    }
+    return [
+        ...candidates,
+        ...escalationIntents.map((intent) => {
+            const escalation = classifyVerificationCandidate(intent, commandContract.intents[intent]);
+            return {
+                ...escalation,
+                detail: escalation.status === 'runnable'
+                    ? 'Declared escalation for a high-risk verification requirement.'
+                    : escalation.detail,
+            };
+        }),
+    ];
+}
+function intentExplicitlySubsumes(commandContract, broaderIntent, narrowerIntent) {
+    return readIntentRelationList(commandContract, broaderIntent, 'subsumes').includes(narrowerIntent);
+}
+function intentExplicitlySubsumedBy(commandContract, narrowerIntent, broaderIntent) {
+    return readIntentRelationList(commandContract, narrowerIntent, 'subsumed_by').includes(broaderIntent);
+}
+function intentRequiresCompanion(commandContract, intent) {
+    return readIntentRelationList(commandContract, intent, 'requires_with').length > 0;
+}
+function intentIsExplicitlySubsumed(commandContract, narrowerIntent, broaderIntent) {
+    return (intentExplicitlySubsumedBy(commandContract, narrowerIntent, broaderIntent) ||
+        intentExplicitlySubsumes(commandContract, broaderIntent, narrowerIntent));
+}
+function selectVerificationCandidates(commandContract, candidates) {
+    const runnableCandidates = candidates.filter((candidate) => candidate.status === 'runnable' && candidate.intent.length > 0);
+    const selectedIntents = new Set(runnableCandidates.map((candidate) => candidate.intent));
+    for (const candidate of runnableCandidates) {
+        const isSubsumed = runnableCandidates.some((other) => other.intent !== candidate.intent && intentIsExplicitlySubsumed(commandContract, candidate.intent, other.intent));
+        if (isSubsumed) {
+            selectedIntents.delete(candidate.intent);
+        }
+    }
+    const costComparableCandidates = runnableCandidates.filter((candidate) => selectedIntents.has(candidate.intent) &&
+        !intentRequiresCompanion(commandContract, candidate.intent) &&
+        intentCoverageSignature(commandContract, candidate.intent) !== null &&
+        readIntentCostExpectedSeconds(commandContract, candidate.intent) !== null);
+    const costComparableGroups = new Map();
+    for (const candidate of costComparableCandidates) {
+        const signature = intentCoverageSignature(commandContract, candidate.intent);
+        if (signature === null) {
+            continue;
+        }
+        costComparableGroups.set(signature, [...(costComparableGroups.get(signature) ?? []), candidate]);
+    }
+    for (const group of costComparableGroups.values()) {
+        if (group.length < 2) {
+            continue;
+        }
+        const costs = group.map((candidate) => readIntentCostExpectedSeconds(commandContract, candidate.intent));
+        if (costs.some((cost) => cost === null)) {
+            continue;
+        }
+        const minCost = Math.min(...costs);
+        const winners = group.filter((candidate) => readIntentCostExpectedSeconds(commandContract, candidate.intent) === minCost);
+        if (winners.length !== 1) {
+            continue;
+        }
+        for (const candidate of group) {
+            if (candidate.intent !== winners[0]?.intent) {
+                selectedIntents.delete(candidate.intent);
+            }
+        }
+    }
+    if (selectedIntents.size === 0 && runnableCandidates.length > 0) {
+        return runnableCandidates;
+    }
+    return runnableCandidates.filter((candidate) => selectedIntents.has(candidate.intent));
+}
+function uniqueVerificationCandidates(candidates) {
+    const byIntent = new Map();
+    for (const candidate of candidates) {
+        if (candidate.intent.length === 0 || byIntent.has(candidate.intent)) {
+            continue;
+        }
+        byIntent.set(candidate.intent, candidate);
+    }
+    return [...byIntent.values()].sort((left, right) => left.intent.localeCompare(right.intent));
+}
+function toChangeVerificationCandidate(reason, candidate, selectedCandidateKeys) {
+    const hasIntent = candidate.intent.length > 0;
+    const isMissingIntent = !hasIntent || candidate.reason === 'no_matching_intents';
+    const isEligible = hasIntent && candidate.status === 'runnable';
     return {
         reason,
         intent: candidate.intent.length > 0 ? candidate.intent : null,
         status: candidate.status,
         skipReason: candidate.reason,
         detail: candidate.detail,
+        candidateState: isMissingIntent ? 'gap' : 'candidate',
+        eligibilityState: isMissingIntent ? 'missing' : isEligible ? 'eligible' : 'ineligible',
+        selectionState: isEligible
+            ? selectedCandidateKeys.has(candidateKey(reason, candidate.intent))
+                ? 'selected'
+                : 'not_selected'
+            : 'not_applicable',
     };
 }
 function gapForRequirement(requirement, candidates) {
@@ -62,17 +275,37 @@ function gapForRequirement(requirement, candidates) {
     };
 }
 export function createChangeVerificationReport(classificationReport, commandContract, projectRoot) {
+    const testSelectionPlan = createProjectTestSelectionPlan(projectRoot, classificationReport, commandContract);
     const requirements = classificationReport.summary.validationReasons.map((reason) => createVerificationRequirement(classificationReport, reason));
     const plans = requirements.map((requirement) => ({
         requirement,
-        candidates: createVerificationPlan(commandContract, requirement.reason).candidates,
+        candidates: expandCandidatesWithDeclaredEscalations(commandContract, requirement, expandCandidatesWithDeclaredFallbacks(commandContract, createVerificationPlan(commandContract, requirement.reason).candidates)),
+    }));
+    const plansWithProjectTestSelection = plans.map((plan) => {
+        const additionalCandidates = testSelectionPlan.candidates
+            .filter((candidate) => candidate.reason === plan.requirement.reason)
+            .filter((candidate) => !plan.candidates.some((existing) => existing.intent === candidate.candidate.intent))
+            .map((candidate) => candidate.candidate);
+        return additionalCandidates.length > 0
+            ? { ...plan, candidates: [...plan.candidates, ...additionalCandidates] }
+            : plan;
+    });
+    const selectedPlans = plansWithProjectTestSelection.map((plan) => ({
+        ...plan,
+        selectedCandidates: uniqueVerificationCandidates([
+            ...selectVerificationCandidates(commandContract, plan.candidates),
+            ...testSelectionPlan.selectedCandidates
+                .filter((candidate) => candidate.reason === plan.requirement.reason)
+                .map((candidate) => candidate.candidate),
+        ]),
     }));
-    const candidatePlans = plans.flatMap((plan) => plan.candidates);
-    const candidates = plans.flatMap((plan) => plan.candidates.map((candidate) => toChangeVerificationCandidate(plan.requirement.reason, candidate)));
+    const selectedCandidatePlans = selectedPlans.flatMap((plan) => plan.selectedCandidates);
+    const selectedCandidateKeys = new Set(selectedPlans.flatMap((plan) => plan.selectedCandidates.map((candidate) => candidateKey(plan.requirement.reason, candidate.intent))));
+    const schedule = createVerificationSchedule(projectRoot, commandContract, selectedCandidatePlans);
+    const candidates = plansWithProjectTestSelection.flatMap((plan) => plan.candidates.map((candidate) => toChangeVerificationCandidate(plan.requirement.reason, candidate, selectedCandidateKeys)));
     const gaps = requirements
         .map((requirement) => gapForRequirement(requirement, candidates))
         .filter((gap) => gap !== null);
-    const schedule = createVerificationSchedule(projectRoot, commandContract, candidatePlans);
     return {
         schema_version: CHANGE_VERIFICATION_SCHEMA_VERSION,
         source: classificationReport.source,
@@ -83,5 +316,6 @@ export function createChangeVerificationReport(classificationReport, commandCont
         gaps,
         schedule,
         decision_graph: createVerificationDecisionGraph(commandContract, requirements, candidates, gaps, schedule),
+        test_selection: testSelectionPlan.report,
     };
 }

package/dist/core/check-issues.js

@@ -24,11 +24,17 @@ const CHECK_ISSUE_ID_RULES = [
     ['mustflow.contract_model.command_authority_field', /^Strict: \.mustflow\/config\/(?:changes|surfaces)\.toml .+ cannot define command authority; use \.mustflow\/config\/commands\.toml$/u],
     ['mustflow.contract_model.invalid_match_kind', /^Strict: \.mustflow\/config\/(?:changes|surfaces)\.toml rules\[\d+\]\.match\.kind must be "exact", "prefix", or "glob"; regular expressions are deferred$/u],
     ['mustflow.contract_model.invalid_shape', /^Strict: \.mustflow\/config\/(?:changes|surfaces)\.toml .+(?:must be|must define|is not allowed)/u],
+    ['mustflow.test_selection.command_authority_field', /^Strict: \.mustflow\/config\/test-selection\.toml .+ cannot define command authority; use \.mustflow\/config\/commands\.toml$/u],
+    ['mustflow.test_selection.unknown_command_intent', /^Strict: \.mustflow\/config\/test-selection\.toml .+ references unknown command intent "[^"]+"$/u],
+    ['mustflow.test_selection.invalid_shape', /^Strict: \.mustflow\/config\/test-selection\.toml .+(?:must be|must define|is not allowed|references command intent "[^"]+" that is not configured)/u],
     ['mustflow.skill.procedure_only', /^Strict: \.mustflow\/skills\/[^/]+\/SKILL\.md metadata\.mustflow_kind must be "procedure"$/u],
     ['mustflow.skill.raw_command_block', /^Strict: \.mustflow\/skills\/[^/]+\/SKILL\.md contains a raw shell command block; reference command intents instead$/u],
     ['mustflow.skill.command_permission_claim', /^Strict: \.mustflow\/skills\/[^/]+\/SKILL\.md claims command execution permission; keep permissions in \.mustflow\/config\/commands\.toml$/u],
     ['mustflow.skill.unknown_command_intent', /^Strict: \.mustflow\/skills\/[^/]+\/SKILL\.md metadata\.command_intents references unknown command intent "[^"]+"$/u],
     ['mustflow.skill.index_route_unknown_command_intent', /^Strict: \.mustflow\/skills\/INDEX\.md route \.mustflow\/skills\/[^/]+\/SKILL\.md references command intent "[^"]+" not declared by the skill frontmatter$/u],
+    ['mustflow.skill.index_route_broad_catch_all', /^Strict warning: \.mustflow\/skills\/INDEX\.md \.mustflow\/skills\/[^/]+\/SKILL\.md route uses broad catch-all trigger ".+" that can shadow narrower skills$/u],
+    ['mustflow.skill.index_route_identical_trigger', /^Strict warning: \.mustflow\/skills\/INDEX\.md \.mustflow\/skills\/[^/]+\/SKILL\.md and \.mustflow\/skills\/[^/]+\/SKILL\.md have identical skill route trigger text$/u],
+    ['mustflow.skill.index_route_duplicate_surface', /^Strict warning: \.mustflow\/skills\/INDEX\.md \.mustflow\/skills\/[^/]+\/SKILL\.md and \.mustflow\/skills\/[^/]+\/SKILL\.md have duplicate edit scope, risk, and expected output route surface$/u],
     ['mustflow.skill.resource_unknown_command_intent', /^Strict: \.mustflow\/skills\/[^/]+\/resources\.toml script [^\s]+ references unknown command intent "[^"]+"$/u],
     ['mustflow.source_anchor.invalid_format', /^Strict: source anchor .+ has invalid format:/u],
     ['mustflow.source_anchor.duplicate_id', /^Strict: source anchor id "[^"]+" is duplicated:/u],

package/dist/core/command-contract-validation.js

@@ -120,6 +120,25 @@ function validateCommandIntentEffects(intentName, intent, issues) {
         }
     }
 }
+function validateCommandIntentSelection(intentName, intent, issues) {
+    if (!hasOwn(intent, 'selection')) {
+        return;
+    }
+    if (!isRecord(intent.selection)) {
+        issues.push(commandContractIssue(`[commands.intents.${intentName}.selection] must be a TOML table`));
+        return;
+    }
+    const selection = intent.selection;
+    validateStringField(selection, 'coverage_level', `[commands.intents.${intentName}.selection].coverage_level`, issues);
+    validateStringField(selection, 'coverage_confidence', `[commands.intents.${intentName}.selection].coverage_confidence`, issues);
+    validateStringField(selection, 'accepts_changed_files', `[commands.intents.${intentName}.selection].accepts_changed_files`, issues);
+    validateStringArrayField(selection, 'fallback_intents', `[commands.intents.${intentName}.selection].fallback_intents`, issues);
+    validateStringArrayField(selection, 'escalate_to', `[commands.intents.${intentName}.selection].escalate_to`, issues);
+    validateBooleanField(selection, 'accepts_test_targets', `[commands.intents.${intentName}.selection].accepts_test_targets`, issues);
+    if (selection.accepts_test_targets === true && intent.status === 'configured' && !Array.isArray(intent.argv)) {
+        issues.push(commandContractIssue(`[commands.intents.${intentName}.selection].accepts_test_targets requires argv command mode`));
+    }
+}
 function validateCommandIntent(intentName, intent, issues) {
     if (!commandIntentNameIsSafe(intentName)) {
         issues.push(commandContractIssue(`Intent ${intentName} name must contain only letters, numbers, underscores, and hyphens`));
@@ -129,6 +148,7 @@ function validateCommandIntent(intentName, intent, issues) {
     validateAllowedStringField(intent, 'run_policy', `[commands.intents.${intentName}].run_policy`, COMMAND_RUN_POLICIES, issues);
     validateAllowedStringField(intent, 'env_policy', `[commands.intents.${intentName}].env_policy`, COMMAND_ENV_POLICIES, issues);
     validateStringArrayField(intent, 'env_allowlist', `[commands.intents.${intentName}].env_allowlist`, issues);
+    validateCommandIntentSelection(intentName, intent, issues);
     if (intent.status !== 'configured') {
         return;
     }

package/dist/core/command-effects.js

@@ -70,6 +70,19 @@ function normalizeDeclaredEffect(projectRoot, commandContract, intentName, inten
     if (!lock && paths.length === 0) {
         throw new Error(`Command effect for intent ${intentName} must define path, paths, or lock`);
     }
+    if (paths.length === 0) {
+        return [
+            {
+                intent: intentName,
+                source: 'effects',
+                access,
+                mode,
+                path: null,
+                lock: lock,
+                concurrency,
+            },
+        ];
+    }
     return paths.map((rawPath) => {
         const normalizedPath = validateEffectPath(projectRoot, intent, rawPath);
         return {

package/dist/core/contract-lint.js

@@ -1,8 +1,11 @@
+import { existsSync, readFileSync } from 'node:fs';
+import path from 'node:path';
 import { COMMAND_LIFECYCLES, COMMAND_RUN_POLICIES, LONG_RUNNING_LIFECYCLES, isRecord, readPositiveInteger, readString, readStringArray, } from './config-loading.js';
-import { evaluateCommandIntentEligibility } from './command-intent-eligibility.js';
+import { evaluateCommandIntentEligibility, } from './command-intent-eligibility.js';
 import { commandIntentHasBlockedShellBackgroundPattern, commandIntentHasCommandSource, commandIntentNameIsSafe, } from './command-contract-rules.js';
 import { commandEffectsConflict, normalizeCommandEffects } from './command-effects.js';
 import { listChangeClassificationValidationReasons } from './change-classification.js';
+import { parseSkillIndexRoutes } from './skill-route-alignment.js';
 const CONTRACT_LINT_SOURCE_FILES = [
     '.mustflow/config/commands.toml',
     '.mustflow/docs/agent-workflow.md',
@@ -41,9 +44,17 @@ const RELEASE_SENSITIVE_REASONS = new Set([
     'release_risk',
     'template_version_change',
 ]);
+const COMMANDS_CONFIG_PATH = '.mustflow/config/commands.toml';
+const SKILL_INDEX_PATH = '.mustflow/skills/INDEX.md';
+const CHANGE_CLASSIFICATION_SOURCE_PATH = 'src/core/change-classification.ts';
+const AGENT_WORKFLOW_PATH = '.mustflow/docs/agent-workflow.md';
 function uniqueSorted(values) {
     return [...new Set(values)].sort((left, right) => left.localeCompare(right));
 }
+function intersectSorted(left, right) {
+    const rightSet = new Set(right);
+    return uniqueSorted(left.filter((value) => rightSet.has(value)));
+}
 function readBoolean(intent, key) {
     const value = intent[key];
     return typeof value === 'boolean' ? value : null;
@@ -151,6 +162,87 @@ function collectRequiredAfterReasons(contract) {
     }
     return reasonToIntents;
 }
+function readSkillPathsByIntent(projectRoot) {
+    const skillPathsByIntent = new Map();
+    if (!projectRoot) {
+        return skillPathsByIntent;
+    }
+    const skillIndexPath = path.join(projectRoot, ...SKILL_INDEX_PATH.split('/'));
+    if (!existsSync(skillIndexPath)) {
+        return skillPathsByIntent;
+    }
+    const routes = parseSkillIndexRoutes(readFileSync(skillIndexPath, 'utf8'));
+    for (const route of routes) {
+        for (const intent of route.commandIntents) {
+            skillPathsByIntent.set(intent, [...(skillPathsByIntent.get(intent) ?? []), route.skillPath]);
+        }
+    }
+    return skillPathsByIntent;
+}
+function classifyReasonSource(reason, knownClassificationReasons, documentedVerificationReasons) {
+    if (knownClassificationReasons.includes(reason)) {
+        return 'classification';
+    }
+    if (documentedVerificationReasons.includes(reason)) {
+        return 'documented';
+    }
+    return 'required_after';
+}
+function buildRelatedDocs(source, relatedSkills) {
+    const docs = [COMMANDS_CONFIG_PATH];
+    if (source === 'classification') {
+        docs.push(CHANGE_CLASSIFICATION_SOURCE_PATH);
+    }
+    if (source === 'documented') {
+        docs.push(AGENT_WORKFLOW_PATH);
+    }
+    if (relatedSkills.length > 0) {
+        docs.push(SKILL_INDEX_PATH);
+    }
+    return uniqueSorted(docs);
+}
+function buildCoverageMatrix(reasonToIntents, knownClassificationReasons, documentedVerificationReasons, skillPathsByIntent) {
+    const matrixReasons = uniqueSorted([
+        ...knownClassificationReasons,
+        ...documentedVerificationReasons,
+        ...reasonToIntents.keys(),
+    ]);
+    return matrixReasons.map((reason) => {
+        const candidates = [...(reasonToIntents.get(reason) ?? [])].sort((left, right) => left.name.localeCompare(right.name));
+        const source = classifyReasonSource(reason, knownClassificationReasons, documentedVerificationReasons);
+        const intentNames = candidates.map((candidate) => candidate.name);
+        const relatedSkills = uniqueSorted(intentNames.flatMap((intent) => skillPathsByIntent.get(intent) ?? []));
+        const gaps = [];
+        if (candidates.length === 0) {
+            gaps.push('missing_required_after');
+        }
+        else if (!candidates.some((candidate) => candidate.runnable)) {
+            gaps.push('no_runnable_intent');
+        }
+        if (source === 'required_after') {
+            gaps.push('unknown_reason');
+        }
+        if (intentNames.length > 0 && intersectSorted(intentNames, [...skillPathsByIntent.keys()]).length === 0) {
+            gaps.push('no_related_skill_route');
+        }
+        return {
+            reason,
+            source,
+            intents: candidates.map((candidate) => {
+                const eligibility = evaluateCommandIntentEligibility(candidate.name, candidate.intent);
+                return {
+                    intent: candidate.name,
+                    status: eligibility.code,
+                    runnable: eligibility.ok,
+                    detail: eligibility.detail,
+                };
+            }),
+            gaps: uniqueSorted(gaps),
+            relatedSkills,
+            relatedDocs: buildRelatedDocs(source, relatedSkills),
+        };
+    });
+}
 function hasExplicitEffectMetadata(intent) {
     return Array.isArray(intent.effects) && intent.effects.some((effect) => isRecord(effect));
 }
@@ -200,6 +292,7 @@ function lintCoverage(contract, options, issues) {
     const documentedVerificationReasons = [...DOCUMENTED_VERIFICATION_REASONS];
     const knownReasons = new Set([...knownClassificationReasons, ...documentedVerificationReasons]);
     const reasonToIntents = collectRequiredAfterReasons(contract);
+    const skillPathsByIntent = readSkillPathsByIntent(options.projectRoot);
     const requiredAfterReasons = uniqueSorted(reasonToIntents.keys());
     const runnableReasons = uniqueSorted([...reasonToIntents.entries()]
         .filter(([, candidates]) => candidates.some((candidate) => candidate.runnable))
@@ -236,6 +329,7 @@ function lintCoverage(contract, options, issues) {
         documentedVerificationReasons,
         requiredAfterReasons,
         runnableReasons,
+        matrix: buildCoverageMatrix(reasonToIntents, knownClassificationReasons, documentedVerificationReasons, skillPathsByIntent),
         findings,
     };
 }

package/dist/core/dashboard-verification.js

@@ -68,6 +68,11 @@ function createEmptyDashboardVerificationSnapshot(changedFiles) {
         skipped: [],
         schedule: {
             runner: 'serial_mf_run_receipts',
+            failurePolicy: {
+                mode: 'batch_boundary',
+                startedBatch: 'wait_for_completion',
+                nextBatch: 'stop_on_failure',
+            },
             batches: [],
             entries: [],
             notes: [],
@@ -104,6 +109,7 @@ export function createDashboardVerificationSnapshot(projectRoot, rawCommandContr
         skipped,
         schedule: {
             runner: verificationReport.schedule.runner,
+            failurePolicy: verificationReport.schedule.failurePolicy,
             batches: verificationReport.schedule.batches.map((batch) => ({
                 index: batch.index,
                 intents: batch.intents,
@@ -113,6 +119,8 @@ export function createDashboardVerificationSnapshot(projectRoot, rawCommandContr
             entries: verificationReport.schedule.entries.map((entry) => ({
                 intent: entry.intent,
                 command: `mf run ${entry.intent}`,
+                parallelEligible: entry.parallelEligible,
+                parallelReason: entry.parallelReason,
                 locks: entry.locks,
                 effects: entry.effects.map((effect) => ({
                     access: effect.access,

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

@@ -46,6 +46,13 @@ const PUBLIC_JSON_SCHEMA_CONTRACTS = [
         documented: true,
         installedCommand: ['mf', 'contract-lint', '--json'],
     },
+    {
+        id: 'dashboard-export',
+        schemaFile: 'dashboard-export.schema.json',
+        producer: 'mf dashboard --export-json <path>',
+        packaged: true,
+        documented: true,
+    },
     {
         id: 'classify-report',
         schemaFile: 'classify-report.schema.json',