mustflow 1.30.0 → 2.11.0

package/dist/core/scope-risk.js

@@ -0,0 +1,64 @@
+export const SCOPE_DIFF_BUDGET_DEFAULTS = {
+    maxChangedFiles: 8,
+    maxPublicSurfaces: 4,
+    maxChangeKindFamilies: 3,
+    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',
+};
+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 firstPaths(paths) {
+    return paths.slice(0, SCOPE_DIFF_BUDGET_DEFAULTS.maxPathsPerRisk);
+}
+export function createScopeDiffRisks(report) {
+    const risks = [];
+    if (report.summary.fileCount > SCOPE_DIFF_BUDGET_DEFAULTS.maxChangedFiles) {
+        risks.push({
+            code: 'diff_budget_exceeded',
+            severity: 'high',
+            detail: `Changed file count ${report.summary.fileCount} exceeds the conservative completion budget of ${SCOPE_DIFF_BUDGET_DEFAULTS.maxChangedFiles}.`,
+            count: report.summary.fileCount,
+            limit: SCOPE_DIFF_BUDGET_DEFAULTS.maxChangedFiles,
+            paths: firstPaths(report.files),
+        });
+    }
+    if (report.summary.publicSurfaceCount > SCOPE_DIFF_BUDGET_DEFAULTS.maxPublicSurfaces) {
+        risks.push({
+            code: 'public_surface_budget_exceeded',
+            severity: 'high',
+            detail: `Public surface count ${report.summary.publicSurfaceCount} exceeds the conservative completion budget of ${SCOPE_DIFF_BUDGET_DEFAULTS.maxPublicSurfaces}.`,
+            count: report.summary.publicSurfaceCount,
+            limit: SCOPE_DIFF_BUDGET_DEFAULTS.maxPublicSurfaces,
+            paths: firstPaths(report.classifications.filter((classification) => classification.surface.isPublicSurface).map((classification) => classification.path)),
+        });
+    }
+    const changeKindFamilies = uniqueSorted(report.summary.changeKinds.map(changeKindFamily));
+    if (changeKindFamilies.length > SCOPE_DIFF_BUDGET_DEFAULTS.maxChangeKindFamilies) {
+        risks.push({
+            code: 'mixed_change_kind_budget_exceeded',
+            severity: 'medium',
+            detail: `Change kind family count ${changeKindFamilies.length} exceeds the conservative completion budget of ${SCOPE_DIFF_BUDGET_DEFAULTS.maxChangeKindFamilies}: ${changeKindFamilies.join(', ')}.`,
+            count: changeKindFamilies.length,
+            limit: SCOPE_DIFF_BUDGET_DEFAULTS.maxChangeKindFamilies,
+            paths: firstPaths(report.files),
+        });
+    }
+    return risks;
+}

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

@@ -1,14 +1,38 @@
 const SKILL_ROUTE_SOURCE_FILES = [
     '.mustflow/skills/INDEX.md',
+    '.mustflow/skills/routes.toml',
     '.mustflow/skills/*/SKILL.md',
     '.mustflow/config/commands.toml',
     '.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;
 export const SKILL_INDEX_ROUTE_COLUMNS = 'Trigger, Skill Document, Required Input, Edit Scope, Risk, Verification Intents, Expected Output';
+export const SKILL_ROUTE_CATEGORY_LABELS = {
+    bug_failure: 'Bug and Failure',
+    general_code: 'General Code Change',
+    tests: 'Tests and Regression',
+    docs_release: 'Documentation and Release',
+    security_privacy: 'Security and Privacy',
+    data_external: 'Data and External Systems',
+    ui_assets: 'UI and Assets',
+    architecture_patterns: 'Architecture Patterns',
+    workflow_contracts: 'Workflow and Contract Maintenance',
+};
+const SKILL_ROUTE_CATEGORY_BY_HEADING = new Map(Object.entries(SKILL_ROUTE_CATEGORY_LABELS).map(([category, label]) => [label, category]));
 function splitMarkdownTableRow(line) {
     return line
         .trim()
@@ -28,7 +52,13 @@ export function findSkillIndexRoutePathColumn(cells) {
 }
 export function parseSkillIndexRoutes(content) {
     const routes = [];
+    let currentCategory;
     for (const line of content.split(/\r?\n/u)) {
+        const categoryHeading = /^###\s+(.+?)\s*$/u.exec(line.trim())?.[1];
+        if (categoryHeading) {
+            currentCategory = SKILL_ROUTE_CATEGORY_BY_HEADING.get(categoryHeading);
+            continue;
+        }
         if (!line.trim().startsWith('|')) {
             continue;
         }
@@ -52,15 +82,95 @@ export function parseSkillIndexRoutes(content) {
             risk: cells[4] ?? '',
             commandIntents: readBacktickValues(cells[SKILL_INDEX_VERIFICATION_INTENTS_COLUMN_INDEX] ?? ''),
             expectedOutput: cells[6] ?? '',
+            category: currentCategory,
         });
     }
     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/source-anchor-status.js

@@ -19,6 +19,9 @@ const HIGH_RISK_SOURCE_ANCHOR_TAGS = new Set([
     'ssrf',
     'xss',
 ]);
+export function hasHighRiskSourceAnchorRiskTags(risk) {
+    return risk.some((tag) => HIGH_RISK_SOURCE_ANCHOR_TAGS.has(tag));
+}
 function sha256(value) {
     return `sha256:${createHash('sha256').update(value).digest('hex')}`;
 }
@@ -62,7 +65,7 @@ function currentAnchorSignals(risk) {
     };
 }
 function hasHighRisk(risk) {
-    return risk.some((tag) => HIGH_RISK_SOURCE_ANCHOR_TAGS.has(tag));
+    return hasHighRiskSourceAnchorRiskTags(risk);
 }
 function sameSymbolIdentity(left, right) {
     return left.kind === right.kind && left.name !== null && left.name === right.name;

package/dist/core/test-selection.js

@@ -0,0 +1,227 @@
+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';
+const STALE_OR_MISSING_RULES_NOTE = 'Project-declared test selection rules did not cover the current changed files; review .mustflow/config/test-selection.toml for stale or missing rules.';
+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.',
+        ...(matches.length > 0 ? [] : [STALE_OR_MISSING_RULES_NOTE]),
+        'Local index data and performance history may add suggestions later, but must not remove manifest-selected tests.',
+        'Absence of historical failures is not evidence that a test can be omitted.',
+        '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/validation-ratchet.js

@@ -0,0 +1,52 @@
+import { existsSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+const TEST_CHANGE_KINDS = new Set(['test', 'test_fixture']);
+const SKIP_OR_ONLY_MARKER = /\b(?:describe|it|test)\s*\.\s*(?:skip|only)\s*\(/u;
+function isTestClassification(classification) {
+    return classification.surface.category === 'test' || classification.changeKinds.some((kind) => TEST_CHANGE_KINDS.has(kind));
+}
+function resolveInsideRoot(projectRoot, relativePath) {
+    const resolvedPath = path.resolve(projectRoot, relativePath);
+    const relative = path.relative(projectRoot, resolvedPath);
+    if (relative.startsWith('..') || path.isAbsolute(relative)) {
+        return null;
+    }
+    return resolvedPath;
+}
+function fileTextIfReadable(projectRoot, relativePath) {
+    const resolvedPath = resolveInsideRoot(projectRoot, relativePath);
+    if (resolvedPath === null || !existsSync(resolvedPath)) {
+        return null;
+    }
+    try {
+        return readFileSync(resolvedPath, 'utf8');
+    }
+    catch {
+        return null;
+    }
+}
+export function createValidationRatchetRisks(report, projectRoot) {
+    const risks = [];
+    for (const classification of report.classifications.filter(isTestClassification)) {
+        const resolvedPath = resolveInsideRoot(projectRoot, classification.path);
+        if (report.source === 'changed' && (resolvedPath === null || !existsSync(resolvedPath))) {
+            risks.push({
+                code: 'related_test_deleted',
+                severity: 'high',
+                path: classification.path,
+                detail: `Changed test path ${classification.path} is absent; deleted related tests require review before marking the task verified.`,
+            });
+            continue;
+        }
+        const fileText = fileTextIfReadable(projectRoot, classification.path);
+        if (fileText !== null && SKIP_OR_ONLY_MARKER.test(fileText)) {
+            risks.push({
+                code: 'skip_or_only_marker_present',
+                severity: 'medium',
+                path: classification.path,
+                detail: `Changed test path ${classification.path} contains a .skip or .only marker; review whether validation was weakened before marking the task verified.`,
+            });
+        }
+    }
+    return risks;
+}

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,
             },
         });