mustflow 1.30.0 → 1.31.0

package/dist/core/skill-route-alignment.js

@@ -5,6 +5,17 @@ const SKILL_ROUTE_SOURCE_FILES = [
     '.mustflow/docs/agent-workflow.md',
 ];
 const MARKDOWN_TABLE_SEPARATOR_PATTERN = /^:?-{3,}:?$/u;
+const BROAD_CATCH_ALL_TRIGGERS = new Set([
+    'any request',
+    'any task',
+    'any change',
+    'all requests',
+    'all tasks',
+    'all changes',
+    'every request',
+    'every task',
+    'everything',
+]);
 export const SKILL_INDEX_ROUTE_COLUMN_COUNT = 7;
 export const SKILL_INDEX_SKILL_PATH_COLUMN_INDEX = 1;
 export const SKILL_INDEX_VERIFICATION_INTENTS_COLUMN_INDEX = 5;
@@ -56,11 +67,90 @@ export function parseSkillIndexRoutes(content) {
     }
     return routes;
 }
+function normalizeRouteText(value) {
+    return value
+        .toLowerCase()
+        .replace(/`[^`]+`/gu, ' ')
+        .replace(/<[^>]+>/gu, ' ')
+        .replace(/[^a-z0-9]+/gu, ' ')
+        .trim()
+        .replace(/\s+/gu, ' ');
+}
+function collectRoutePairs(routes) {
+    const pairs = [];
+    for (let leftIndex = 0; leftIndex < routes.length; leftIndex += 1) {
+        for (let rightIndex = leftIndex + 1; rightIndex < routes.length; rightIndex += 1) {
+            const left = routes[leftIndex];
+            const right = routes[rightIndex];
+            if (left.skillPath !== right.skillPath) {
+                pairs.push({ left, right });
+            }
+        }
+    }
+    return pairs;
+}
+function routePairLabel(pair) {
+    return `${pair.left.skillPath} and ${pair.right.skillPath}`;
+}
+/**
+ * mf:anchor core.skill-route-conflict-lint
+ * purpose: Keep skill routing warnings deterministic so broad or duplicate route rows are review candidates, not LLM guesses.
+ * search: skill route conflict, duplicate trigger, broad catch-all route
+ * invariant: Route conflict warnings are heuristic warnings only; missing routes and command-intent drift remain strict errors.
+ * risk: config
+ */
+export function findSkillRouteConflictWarnings(routes) {
+    const warnings = [];
+    const triggerToRoutes = new Map();
+    const surfaceToRoutes = new Map();
+    for (const route of routes) {
+        const trigger = normalizeRouteText(route.trigger);
+        const editScope = normalizeRouteText(route.editScope);
+        const risk = normalizeRouteText(route.risk);
+        const expectedOutput = normalizeRouteText(route.expectedOutput);
+        if (BROAD_CATCH_ALL_TRIGGERS.has(trigger)) {
+            warnings.push(`${route.skillPath} route uses broad catch-all trigger "${route.trigger}" that can shadow narrower skills`);
+        }
+        if (trigger) {
+            triggerToRoutes.set(trigger, [...(triggerToRoutes.get(trigger) ?? []), route]);
+        }
+        if (editScope && risk && expectedOutput) {
+            const surfaceKey = `${editScope}\n${risk}\n${expectedOutput}`;
+            surfaceToRoutes.set(surfaceKey, [...(surfaceToRoutes.get(surfaceKey) ?? []), route]);
+        }
+    }
+    for (const pair of collectRoutePairs([...triggerToRoutes.values()].flatMap((matchingRoutes) => {
+        return matchingRoutes.length > 1 ? matchingRoutes : [];
+    }))) {
+        if (normalizeRouteText(pair.left.trigger) === normalizeRouteText(pair.right.trigger)) {
+            warnings.push(`${routePairLabel(pair)} have identical skill route trigger text`);
+        }
+    }
+    for (const pair of collectRoutePairs([...surfaceToRoutes.values()].flatMap((matchingRoutes) => {
+        return matchingRoutes.length > 1 ? matchingRoutes : [];
+    }))) {
+        const leftSurface = [
+            normalizeRouteText(pair.left.editScope),
+            normalizeRouteText(pair.left.risk),
+            normalizeRouteText(pair.left.expectedOutput),
+        ].join('\n');
+        const rightSurface = [
+            normalizeRouteText(pair.right.editScope),
+            normalizeRouteText(pair.right.risk),
+            normalizeRouteText(pair.right.expectedOutput),
+        ].join('\n');
+        if (leftSurface === rightSurface) {
+            warnings.push(`${routePairLabel(pair)} have duplicate edit scope, risk, and expected output route surface`);
+        }
+    }
+    return [...new Set(warnings)].sort((left, right) => left.localeCompare(right));
+}
 function pluralize(count, singular, plural) {
     return count === 1 ? singular : plural;
 }
 export function isSkillRouteAlignmentIssue(issue) {
     return (issue.includes('.mustflow/skills/INDEX.md route') ||
+        issue.includes('.mustflow/skills/INDEX.md .mustflow/skills/') ||
         issue.includes('.mustflow/skills/INDEX.md has duplicate route') ||
         issue.endsWith(' is not listed in .mustflow/skills/INDEX.md'));
 }

package/dist/core/test-selection.js

@@ -0,0 +1,224 @@
+import { existsSync } from 'node:fs';
+import { isRecord, readStringArray, resolveMustflowConfigPath, } from './config-loading.js';
+import { readTomlFile } from './toml.js';
+import { classifyVerificationCandidate, } from './verification-plan.js';
+export const TEST_SELECTION_CONFIG_RELATIVE_PATH = '.mustflow/config/test-selection.toml';
+function uniqueSorted(values) {
+    return [...new Set(values)].sort((left, right) => left.localeCompare(right));
+}
+function toPosixPath(value) {
+    return value.replace(/\\/g, '/');
+}
+function escapeRegExp(value) {
+    return value.replace(/[\\^$+?.()|[\]{}]/g, '\\$&');
+}
+function globToRegExp(pattern) {
+    const normalized = toPosixPath(pattern).replace(/^\/+/u, '');
+    let source = '^';
+    for (let index = 0; index < normalized.length;) {
+        if (normalized.startsWith('**', index)) {
+            source += '.*';
+            index += 2;
+            continue;
+        }
+        const char = normalized[index];
+        if (char === '*') {
+            source += '[^/]*';
+            index += 1;
+            continue;
+        }
+        source += escapeRegExp(char ?? '');
+        index += 1;
+    }
+    return new RegExp(`${source}$`, 'u');
+}
+function readStringField(table, key) {
+    const value = table[key];
+    return typeof value === 'string' && value.trim().length > 0 ? value : null;
+}
+function readRule(value) {
+    if (!isRecord(value) || !isRecord(value.match) || !isRecord(value.select)) {
+        return null;
+    }
+    const id = readStringField(value, 'id');
+    const risk = readStringField(value, 'risk');
+    const reason = readStringField(value, 'reason');
+    const paths = readStringArray(value.match, 'paths');
+    const surfaces = readStringArray(value.match, 'surfaces');
+    const intent = readStringField(value.select, 'intent');
+    const fallbackIntent = readStringField(value.select, 'fallback_intent');
+    const testTargets = readStringArray(value.select, 'test_targets') ?? [];
+    if (!id || !risk || !reason || !paths || paths.length === 0 || !surfaces || surfaces.length === 0 || !intent || !fallbackIntent) {
+        return null;
+    }
+    return {
+        id,
+        risk,
+        reason,
+        paths: uniqueSorted(paths),
+        surfaces: uniqueSorted(surfaces),
+        intent,
+        fallbackIntent,
+        testTargets: uniqueSorted(testTargets),
+    };
+}
+function readRules(projectRoot) {
+    const configPath = resolveMustflowConfigPath(projectRoot, TEST_SELECTION_CONFIG_RELATIVE_PATH);
+    if (!existsSync(configPath)) {
+        return {
+            status: 'missing',
+            rules: [],
+            note: 'No project-declared test selection manifest exists; mustflow will not infer a user-project test subset.',
+        };
+    }
+    try {
+        const parsed = readTomlFile(configPath);
+        if (!isRecord(parsed) || parsed.schema_version !== '1' || !Array.isArray(parsed.rules)) {
+            return {
+                status: 'invalid',
+                rules: [],
+                note: 'Project-declared test selection manifest is invalid; run mf check --strict before relying on it.',
+            };
+        }
+        const rules = parsed.rules.map(readRule);
+        if (!rules.every((rule) => rule !== null)) {
+            return {
+                status: 'invalid',
+                rules: [],
+                note: 'Project-declared test selection manifest has invalid rule shapes; run mf check --strict before relying on it.',
+            };
+        }
+        return { status: 'loaded', rules };
+    }
+    catch {
+        return {
+            status: 'invalid',
+            rules: [],
+            note: 'Project-declared test selection manifest cannot be read; run mf check --strict before relying on it.',
+        };
+    }
+}
+function ruleMatchesClassification(rule, classification) {
+    const pathMatches = rule.paths.some((pattern) => globToRegExp(pattern).test(toPosixPath(classification.path)));
+    const surfaceMatches = rule.surfaces.includes(classification.surface.kind);
+    return pathMatches && surfaceMatches;
+}
+function matchingClassifications(rule, report) {
+    return report.classifications.filter((classification) => ruleMatchesClassification(rule, classification));
+}
+function selectReason(classifications) {
+    return (classifications.flatMap((classification) => classification.surface.validationReasons)[0] ??
+        'unknown_change');
+}
+function withDetail(candidate, detail) {
+    return {
+        ...candidate,
+        detail: candidate.detail ?? detail,
+    };
+}
+function commandAcceptsTestTargets(commandContract, intent) {
+    const rawIntent = commandContract.intents[intent];
+    return isRecord(rawIntent) && isRecord(rawIntent.selection) && rawIntent.selection.accepts_test_targets === true;
+}
+function appliedTestTargetsForCandidate(rule, commandContract, candidate) {
+    return candidate.status === 'runnable' && commandAcceptsTestTargets(commandContract, candidate.intent)
+        ? rule.testTargets
+        : [];
+}
+function toReportCandidate(rule, reason, role, candidate, appliedTestTargets) {
+    return {
+        ruleId: rule.id,
+        reason,
+        intent: candidate.intent,
+        role,
+        status: candidate.status,
+        skipReason: candidate.reason,
+        detail: candidate.detail,
+        testTargets: rule.testTargets,
+        appliedTestTargets,
+        testTargetsApplied: appliedTestTargets.length > 0,
+    };
+}
+export function createProjectTestSelectionPlan(projectRoot, classificationReport, commandContract) {
+    const loaded = readRules(projectRoot);
+    if (loaded.status !== 'loaded') {
+        const status = loaded.status;
+        return {
+            report: {
+                source: 'test-selection.toml',
+                status,
+                configPath: TEST_SELECTION_CONFIG_RELATIVE_PATH,
+                authority: TEST_SELECTION_CONFIG_RELATIVE_PATH,
+                commandAuthority: '.mustflow/config/commands.toml',
+                grantsCommandAuthority: false,
+                matches: [],
+                selected: [],
+                notes: [loaded.note],
+            },
+            candidates: [],
+            selectedCandidates: [],
+        };
+    }
+    const matches = [];
+    const candidates = [];
+    const selectedCandidates = [];
+    const selectedReportCandidates = [];
+    for (const rule of loaded.rules) {
+        const classifications = matchingClassifications(rule, classificationReport);
+        if (classifications.length === 0) {
+            continue;
+        }
+        const reason = selectReason(classifications);
+        matches.push({
+            ruleId: rule.id,
+            risk: rule.risk,
+            reason: rule.reason,
+            files: uniqueSorted(classifications.map((classification) => classification.path)),
+            surfaces: uniqueSorted(classifications.map((classification) => classification.surface.kind)),
+            intent: rule.intent,
+            fallbackIntent: rule.fallbackIntent,
+            testTargets: rule.testTargets,
+        });
+        const primary = withDetail(classifyVerificationCandidate(rule.intent, commandContract.intents[rule.intent]), `Project-declared test selection rule "${rule.id}".`);
+        const primaryTestTargets = appliedTestTargetsForCandidate(rule, commandContract, primary);
+        const primaryCandidate = { reason, candidate: primary, testTargets: primaryTestTargets };
+        candidates.push(primaryCandidate);
+        if (primary.status === 'runnable') {
+            selectedCandidates.push(primaryCandidate);
+            selectedReportCandidates.push(toReportCandidate(rule, reason, 'primary', primary, primaryTestTargets));
+            continue;
+        }
+        selectedReportCandidates.push(toReportCandidate(rule, reason, 'primary', primary, primaryTestTargets));
+        const fallback = withDetail(classifyVerificationCandidate(rule.fallbackIntent, commandContract.intents[rule.fallbackIntent]), `Fallback for project-declared test selection rule "${rule.id}".`);
+        const fallbackTestTargets = appliedTestTargetsForCandidate(rule, commandContract, fallback);
+        const fallbackCandidate = { reason, candidate: fallback, testTargets: fallbackTestTargets };
+        candidates.push(fallbackCandidate);
+        if (fallback.status === 'runnable') {
+            selectedCandidates.push(fallbackCandidate);
+            selectedReportCandidates.push(toReportCandidate(rule, reason, 'fallback', fallback, fallbackTestTargets));
+        }
+    }
+    const status = matches.length > 0 ? 'matched' : 'unmatched';
+    const notes = [
+        matches.length > 0
+            ? 'Matched project-declared test selection rules are treated as a minimum selected set.'
+            : 'No project-declared test selection rules matched the current changed files.',
+        'Local index data and performance history may add suggestions later, but must not remove manifest-selected tests.',
+        'Test targets are passed only when the selected command intent declares selection.accepts_test_targets = true.',
+    ];
+    return {
+        report: {
+            source: 'test-selection.toml',
+            status,
+            configPath: TEST_SELECTION_CONFIG_RELATIVE_PATH,
+            authority: TEST_SELECTION_CONFIG_RELATIVE_PATH,
+            commandAuthority: '.mustflow/config/commands.toml',
+            grantsCommandAuthority: false,
+            matches,
+            selected: selectedReportCandidates,
+            notes,
+        },
+        candidates,
+        selectedCandidates,
+    };
+}

package/dist/core/verification-decision-graph.js

@@ -25,6 +25,63 @@ function readCommandEffects(rawIntent) {
         concurrency: readString(effect, 'concurrency') ?? null,
     }));
 }
+function readNonNegativeNumber(table, key) {
+    const value = table[key];
+    return typeof value === 'number' && Number.isFinite(value) && value >= 0 ? value : null;
+}
+function readNonNegativeInteger(table, key) {
+    const value = table[key];
+    return Number.isInteger(value) && Number(value) >= 0 ? Number(value) : null;
+}
+function readCoverageHints(rawIntent) {
+    const covers = rawIntent.covers;
+    if (!isRecord(covers)) {
+        return null;
+    }
+    return {
+        reasons: readStringArray(covers, 'reasons') ?? [],
+        surfaces: readStringArray(covers, 'surfaces') ?? [],
+        paths: readStringArray(covers, 'paths') ?? [],
+        contracts: readStringArray(covers, 'contracts') ?? [],
+    };
+}
+function readSelectionHints(rawIntent) {
+    const selection = rawIntent.selection;
+    if (!isRecord(selection)) {
+        return null;
+    }
+    return {
+        coverage_level: readString(selection, 'coverage_level') ?? null,
+        coverage_confidence: readString(selection, 'coverage_confidence') ?? null,
+        accepts_changed_files: readString(selection, 'accepts_changed_files') ?? null,
+        fallback_intents: readStringArray(selection, 'fallback_intents') ?? [],
+        escalate_to: readStringArray(selection, 'escalate_to') ?? [],
+    };
+}
+function readCostHints(rawIntent) {
+    const cost = rawIntent.cost;
+    if (!isRecord(cost)) {
+        return null;
+    }
+    return {
+        expected_seconds: readNonNegativeInteger(cost, 'expected_seconds'),
+        cold_start_seconds: readNonNegativeInteger(cost, 'cold_start_seconds'),
+        timeout_ratio_expectation: readNonNegativeNumber(cost, 'timeout_ratio_expectation'),
+        cost_tier: readString(cost, 'cost_tier') ?? null,
+    };
+}
+function readRelationHints(rawIntent) {
+    const relations = rawIntent.relations;
+    if (!isRecord(relations)) {
+        return null;
+    }
+    return {
+        subsumes: readStringArray(relations, 'subsumes') ?? [],
+        subsumed_by: readStringArray(relations, 'subsumed_by') ?? [],
+        requires_with: readStringArray(relations, 'requires_with') ?? [],
+        escalate_to: readStringArray(relations, 'escalate_to') ?? [],
+    };
+}
 function readCommandMetadata(commandContract, intent) {
     if (!intent) {
         return null;
@@ -44,6 +101,10 @@ function readCommandMetadata(commandContract, intent) {
         required_after: readStringArray(rawIntent, 'required_after') ?? [],
         network: readBoolean(rawIntent, 'network'),
         destructive: readBoolean(rawIntent, 'destructive'),
+        covers: readCoverageHints(rawIntent),
+        selection: readSelectionHints(rawIntent),
+        cost: readCostHints(rawIntent),
+        relations: readRelationHints(rawIntent),
     };
 }
 function candidateDecisionStatus(commandContract, candidate) {
@@ -85,6 +146,9 @@ function summarize(nodes, edgeCount) {
         blocked: nodes.filter((node) => node.status === 'blocked').length,
         manual_only: nodes.filter((node) => node.status === 'manual_only').length,
         unknown: nodes.filter((node) => node.status === 'unknown').length,
+        selected: nodes.filter((node) => node.kind === 'command_candidate' && node.data.selectionState === 'selected').length,
+        not_selected: nodes.filter((node) => node.kind === 'command_candidate' && node.data.selectionState === 'not_selected')
+            .length,
         gapCount: nodes.filter((node) => node.kind === 'gap').length,
     };
 }
@@ -146,6 +210,9 @@ export function createVerificationDecisionGraph(commandContract, requirements, c
                 candidateStatus: candidate.status,
                 skipReason: candidate.skipReason,
                 detail: candidate.detail,
+                candidateState: candidate.candidateState ?? null,
+                eligibilityState: candidate.eligibilityState ?? null,
+                selectionState: candidate.selectionState ?? null,
                 command,
             },
         });

package/dist/core/verification-scheduler.js

@@ -1,3 +1,5 @@
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
 import { commandEffectsConflict, normalizeCommandEffects, } from './command-effects.js';
 function uniqueSorted(values) {
     return [...new Set(values)].sort((left, right) => left.localeCompare(right));
@@ -13,6 +15,79 @@ function toScheduleEffect(effect) {
         concurrency: effect.concurrency,
     };
 }
+function isObject(value) {
+    return !!value && typeof value === 'object';
+}
+function readJsonFile(filePath) {
+    try {
+        return JSON.parse(readFileSync(filePath, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function getUndeclaredWriteIntent(value) {
+    if (!isObject(value) || typeof value.intent !== 'string') {
+        return null;
+    }
+    const writeDrift = value.write_drift;
+    if (!isObject(writeDrift) || writeDrift.has_undeclared_changes !== true) {
+        return null;
+    }
+    return value.intent;
+}
+function resolveStateRelativePath(projectRoot, relativePath) {
+    if (typeof relativePath !== 'string' || relativePath.length === 0 || path.isAbsolute(relativePath)) {
+        return null;
+    }
+    const normalized = relativePath.replaceAll('\\', '/');
+    if (!normalized.startsWith('.mustflow/state/runs/')) {
+        return null;
+    }
+    const resolved = path.resolve(projectRoot, normalized);
+    const relative = path.relative(projectRoot, resolved);
+    if (relative.startsWith('..') || path.isAbsolute(relative)) {
+        return null;
+    }
+    return resolved;
+}
+function readVerifyManifestUndeclaredWriteIntents(projectRoot, latest) {
+    const manifestPath = resolveStateRelativePath(projectRoot, latest.manifest_path);
+    if (!manifestPath) {
+        return new Set();
+    }
+    const manifest = readJsonFile(manifestPath);
+    if (!isObject(manifest) || manifest.command !== 'verify' || !Array.isArray(manifest.receipts)) {
+        return new Set();
+    }
+    const intents = new Set();
+    for (const entry of manifest.receipts) {
+        if (!isObject(entry)) {
+            continue;
+        }
+        const receiptPath = resolveStateRelativePath(projectRoot, entry.receipt_path);
+        if (!receiptPath) {
+            continue;
+        }
+        const intent = getUndeclaredWriteIntent(readJsonFile(receiptPath));
+        if (intent) {
+            intents.add(intent);
+        }
+    }
+    return intents;
+}
+function readLatestUndeclaredWriteIntents(projectRoot) {
+    const latestPath = path.join(projectRoot, '.mustflow', 'state', 'runs', 'latest.json');
+    const parsed = readJsonFile(latestPath);
+    const directIntent = getUndeclaredWriteIntent(parsed);
+    if (directIntent) {
+        return new Set([directIntent]);
+    }
+    if (!isObject(parsed) || parsed.command !== 'verify') {
+        return new Set();
+    }
+    return readVerifyManifestUndeclaredWriteIntents(projectRoot, parsed);
+}
 function entriesConflict(left, right) {
     const conflicts = [];
     for (const leftEffect of left.effects) {
@@ -33,7 +108,8 @@ function entriesConflict(left, right) {
 function addEntryToBatches(batches, batchEntries, entry) {
     for (let batchIndex = 0; batchIndex < batchEntries.length; batchIndex += 1) {
         const existingEntries = batchEntries[batchIndex] ?? [];
-        const hasConflict = existingEntries.some((existing) => entriesConflict(entry, existing).length > 0);
+        const hasConflict = !entry.parallelEligible ||
+            existingEntries.some((existing) => !existing.parallelEligible || entriesConflict(entry, existing).length > 0);
         if (hasConflict) {
             continue;
         }
@@ -55,14 +131,24 @@ function addEntryToBatches(batches, batchEntries, entry) {
     });
 }
 export function createVerificationSchedule(projectRoot, commandContract, candidates) {
+    const latestUndeclaredWriteIntents = readLatestUndeclaredWriteIntents(projectRoot);
     const runnableIntents = uniqueSorted(candidates
         .filter((candidate) => candidate.status === 'runnable' && candidate.intent.length > 0)
         .map((candidate) => candidate.intent));
     const baseEntries = runnableIntents.map((intent) => {
         const effects = normalizeCommandEffects(projectRoot, commandContract, intent).map(toScheduleEffect);
+        const hasExplicitEffects = effects.length > 0 && effects.every((effect) => effect.source === 'effects');
+        const hasUndeclaredWriteDrift = latestUndeclaredWriteIntents.has(intent);
+        const parallelEligible = hasExplicitEffects && !hasUndeclaredWriteDrift;
         return {
             intent,
             status: 'runnable',
+            parallelEligible,
+            parallelReason: hasUndeclaredWriteDrift
+                ? 'undeclared_write_drift'
+                : hasExplicitEffects
+                    ? 'explicit_effects'
+                    : 'missing_explicit_effects',
             effects,
             locks: uniqueSorted(effects.map((effect) => effect.lock)),
             conflicts: [],
@@ -82,11 +168,19 @@ export function createVerificationSchedule(projectRoot, commandContract, candida
     }
     return {
         runner: 'serial_mf_run_receipts',
+        failurePolicy: {
+            mode: 'batch_boundary',
+            startedBatch: 'wait_for_completion',
+            nextBatch: 'stop_on_failure',
+        },
         batches,
         entries,
         notes: [
             'Batches explain resource compatibility for planning only.',
-            'mf run still writes the latest receipt to a single path, so execute copied commands serially.',
+            'Only entries backed by explicit effects are marked parallel eligible; writes fallback remains serial-only.',
+            ...uniqueSorted(latestUndeclaredWriteIntents).map((intent) => `Latest receipt for ${intent} reported undeclared writes; it is not parallel eligible.`),
+            'If a future parallel batch has already started, let it finish and stop before the next batch on failure.',
+            'mf verify still executes copied commands serially and writes the latest run summary after the batch completes.',
         ],
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mustflow",
-  "version": "1.30.0",
+  "version": "1.31.0",
   "description": "Agent workflow documents and CLI for mustflow repository roots.",
   "type": "module",
   "license": "MIT-0",

package/schemas/README.md

@@ -9,9 +9,12 @@ Current schemas:
 - `adapter-compatibility-report.schema.json`: output of `mf adapters status --json`
 - `context-report.schema.json`: output of `mf context --json`
 - `run-receipt.schema.json`: output of `mf run <intent> --json` and `.mustflow/state/runs/latest.json`,
-  including bounded declared-write drift metadata
+  including bounded declared-write drift metadata, a safe latest-run performance summary, and optional
+  structured phase timings and selection summaries
 - `commands.schema.json`: parsed `.mustflow/config/commands.toml`
 - `contract-lint-report.schema.json`: output of `mf contract-lint --json`
+- `dashboard-export.schema.json`: bounded static export written by `mf dashboard --export-json <path>`,
+  including output policy, redaction and truncation metadata, and the dashboard harness report
 - `classify-report.schema.json`: output of `mf classify --changed --json` and  
   `mf classify <path...> --json`
 - `impact-report.schema.json`: output of `mf impact --changed --json` and  
@@ -28,7 +31,8 @@ Current schemas:
 - `verify-report.schema.json`: output of `mf verify --reason <event> --json`
 - `change-verification-report.schema.json`: output of `mf verify --reason <event> --plan-only --json` and  
   `mf verify --from-plan <classify-report.json> --plan-only --json`, including the `decision_graph` that links
-  changed surfaces, classification reasons, command candidates, eligibility, effects, and gaps.
+  changed surfaces, classification reasons, command candidates, eligibility, selected or not-selected state,
+  effects, and gaps.
   Local-index command-effect graphs are explanation-only and cannot grant command authority.
 
 These schemas define stable, automation-facing fields. Human-readable command