mustflow 1.30.0 → 2.11.0

package/dist/core/bounded-output.js

@@ -0,0 +1,38 @@
+export class BoundedOutputBuffer {
+    #maxTailBytes;
+    #chunks = [];
+    #tailBytes = 0;
+    #bytes = 0;
+    constructor(maxTailBytes) {
+        this.#maxTailBytes = Math.max(0, maxTailBytes);
+    }
+    append(chunk) {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, 'utf8');
+        this.#bytes += buffer.byteLength;
+        if (this.#maxTailBytes === 0 || buffer.byteLength === 0) {
+            return;
+        }
+        this.#chunks.push(buffer);
+        this.#tailBytes += buffer.byteLength;
+        while (this.#tailBytes > this.#maxTailBytes && this.#chunks.length > 0) {
+            const first = this.#chunks[0];
+            const overflow = this.#tailBytes - this.#maxTailBytes;
+            if (!first) {
+                break;
+            }
+            if (first.byteLength <= overflow) {
+                this.#chunks.shift();
+                this.#tailBytes -= first.byteLength;
+                continue;
+            }
+            this.#chunks[0] = first.subarray(overflow);
+            this.#tailBytes -= overflow;
+        }
+    }
+    toSnapshot() {
+        return {
+            bytes: this.#bytes,
+            tail: Buffer.concat(this.#chunks, this.#tailBytes).toString('utf8'),
+        };
+    }
+}

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,23 @@ 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.route_metadata_missing', /^Strict: \.mustflow\/skills\/routes\.toml is missing metadata for route "[^"]+"$/u],
+    ['mustflow.skill.route_metadata_unlisted', /^Strict: \.mustflow\/skills\/routes\.toml route "[^"]+" is not listed in \.mustflow\/skills\/INDEX\.md$/u],
+    ['mustflow.skill.route_metadata_missing_document', /^Strict: \.mustflow\/skills\/routes\.toml route "[^"]+" points to a missing skill document$/u],
+    ['mustflow.skill.route_metadata_category_mismatch', /^Strict: \.mustflow\/skills\/INDEX\.md route "[^"]+" must appear under the .+ category section from \.mustflow\/skills\/routes\.toml$/u],
+    ['mustflow.skill.route_metadata_unknown_reference', /^Strict: \.mustflow\/skills\/routes\.toml route "[^"]+" references unknown mutually exclusive route "[^"]+"$/u],
+    ['mustflow.skill.route_metadata_asymmetric_exclusion', /^Strict warning: \.mustflow\/skills\/routes\.toml route "[^"]+" lists "[^"]+" as mutually exclusive but the reverse route does not$/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/completion-verdict.js

@@ -0,0 +1,209 @@
+function verifyStatus(input) {
+    if (input.failedIntents > 0) {
+        const contradictions = ['one_or_more_selected_verification_intents_failed'];
+        if ((input.repeatedFailureCount ?? 0) > 0) {
+            contradictions.push('repeated_verification_failure');
+        }
+        return {
+            status: 'contradicted',
+            primaryReason: 'verification_failed',
+            blockers: [],
+            contradictions,
+            limitations: [],
+        };
+    }
+    if (input.ranIntents === 0 && input.skippedIntents > 0) {
+        const blockers = ['all_matching_verification_intents_were_skipped'];
+        if ((input.repeatedFailureCount ?? 0) > 0) {
+            blockers.push('repeated_verification_failure');
+        }
+        return {
+            status: 'blocked',
+            primaryReason: 'no_runnable_verification_intents',
+            blockers,
+            contradictions: [],
+            limitations: [],
+        };
+    }
+    if (input.ranIntents === 0) {
+        const limitations = ['no_verification_intents_ran'];
+        if ((input.repeatedFailureCount ?? 0) > 0) {
+            limitations.push('repeated_verification_failure');
+        }
+        return {
+            status: 'unverified',
+            primaryReason: 'no_verification_evidence',
+            blockers: [],
+            contradictions: [],
+            limitations,
+        };
+    }
+    if (input.skippedIntents > 0) {
+        const limitations = ['one_or_more_matching_verification_intents_were_skipped'];
+        if ((input.repeatedFailureCount ?? 0) > 0) {
+            limitations.push('repeated_verification_failure');
+        }
+        return {
+            status: 'partially_verified',
+            primaryReason: 'some_verification_skipped',
+            blockers: [],
+            contradictions: [],
+            limitations,
+        };
+    }
+    const downgradeLimitations = [];
+    if ((input.sourceAnchorRiskCount ?? 0) > 0) {
+        downgradeLimitations.push('high_risk_source_anchor_requires_review');
+    }
+    if ((input.scopeDiffRiskCount ?? 0) > 0) {
+        downgradeLimitations.push('scope_diff_risk_requires_review');
+    }
+    if ((input.validationRatchetRiskCount ?? 0) > 0) {
+        downgradeLimitations.push('validation_ratchet_risk_requires_review');
+    }
+    if ((input.reproEvidenceRiskCount ?? 0) > 0) {
+        downgradeLimitations.push('repro_evidence_missing');
+    }
+    if ((input.externalEvidenceRiskCount ?? 0) > 0) {
+        downgradeLimitations.push('external_evidence_requires_review');
+    }
+    if (downgradeLimitations.length > 0) {
+        return {
+            status: 'partially_verified',
+            primaryReason: (input.sourceAnchorRiskCount ?? 0) > 0
+                ? 'source_anchor_invariant_review_required'
+                : (input.scopeDiffRiskCount ?? 0) > 0
+                    ? 'scope_diff_review_required'
+                    : (input.validationRatchetRiskCount ?? 0) > 0
+                        ? 'validation_ratchet_review_required'
+                        : (input.reproEvidenceRiskCount ?? 0) > 0
+                            ? 'repro_evidence_missing'
+                            : 'external_evidence_review_required',
+            blockers: [],
+            contradictions: [],
+            limitations: downgradeLimitations,
+        };
+    }
+    if (input.passedIntents === input.ranIntents) {
+        return {
+            status: 'verified',
+            primaryReason: 'all_selected_verification_passed',
+            blockers: [],
+            contradictions: [],
+            limitations: [],
+        };
+    }
+    return {
+        status: 'unverified',
+        primaryReason: 'verification_evidence_inconclusive',
+        blockers: [],
+        contradictions: [],
+        limitations: ['selected_verification_did_not_produce_a_clear_pass_or_fail'],
+    };
+}
+export function createVerifyCompletionVerdict(input) {
+    const result = verifyStatus(input);
+    return {
+        schema_version: '1',
+        status: result.status,
+        primary_reason: result.primaryReason,
+        evidence: {
+            source: 'mf_verify',
+            verification_plan_id: input.verificationPlanId,
+            changed_file_count: null,
+            matched_intents: input.matchedIntents,
+            ran_intents: input.ranIntents,
+            passed_intents: input.passedIntents,
+            failed_intents: input.failedIntents,
+            skipped_intents: input.skippedIntents,
+            receipt_count: input.receiptCount,
+            gap_count: input.skippedIntents,
+            source_anchor_risk_count: input.sourceAnchorRiskCount ?? 0,
+            scope_diff_risk_count: input.scopeDiffRiskCount ?? 0,
+            repeated_failure_count: input.repeatedFailureCount ?? 0,
+            validation_ratchet_risk_count: input.validationRatchetRiskCount ?? 0,
+            latest_run_status: null,
+        },
+        blockers: result.blockers,
+        contradictions: result.contradictions,
+        limitations: result.limitations,
+    };
+}
+export function createDashboardCompletionVerdict(input) {
+    const latestRunFailed = input.latestRunStatus === 'failed' ||
+        input.latestRunStatus === 'timed_out' ||
+        input.latestRunStatus === 'start_failed';
+    let status = 'unverified';
+    let primaryReason = 'dashboard_does_not_execute_verification';
+    const blockers = [];
+    const contradictions = [];
+    const limitations = ['dashboard_export_is_read_only'];
+    if (latestRunFailed) {
+        status = 'contradicted';
+        primaryReason = 'latest_run_failed';
+        contradictions.push('latest_run_status_is_not_passing');
+    }
+    else if ((input.sourceAnchorRiskCount ?? 0) > 0) {
+        status = 'partially_verified';
+        primaryReason = 'source_anchor_invariant_review_required';
+        limitations.push('high_risk_source_anchor_requires_review');
+        if ((input.scopeDiffRiskCount ?? 0) > 0) {
+            limitations.push('scope_diff_risk_requires_review');
+        }
+    }
+    else if ((input.scopeDiffRiskCount ?? 0) > 0) {
+        status = 'partially_verified';
+        primaryReason = 'scope_diff_review_required';
+        limitations.push('scope_diff_risk_requires_review');
+    }
+    else if (input.gapCount > 0) {
+        status = 'blocked';
+        primaryReason = 'verification_gaps_present';
+        blockers.push('dashboard_verification_graph_reports_gaps');
+    }
+    else if (input.changedFileCount > 0 && !input.latestRunExists) {
+        status = 'unverified';
+        primaryReason = 'changed_files_without_run_receipt';
+        limitations.push('no_latest_run_receipt');
+    }
+    else if (input.changedFileCount > 0 && !input.latestRunValid) {
+        status = 'unverified';
+        primaryReason = 'changed_files_with_invalid_run_receipt';
+        limitations.push('latest_run_receipt_is_invalid');
+    }
+    else if (input.changedFileCount > 0 && input.runnableIntentCount > 0) {
+        status = 'partially_verified';
+        primaryReason = 'verification_recommendations_available';
+        limitations.push('dashboard_recommendations_are_not_executed_receipts');
+    }
+    else if (input.latestRunValid && input.latestRunStatus === 'passed') {
+        status = 'partially_verified';
+        primaryReason = 'latest_run_passed_without_current_claim_binding';
+        limitations.push('latest_run_is_not_bound_to_a_current_completion_claim');
+    }
+    return {
+        schema_version: '1',
+        status,
+        primary_reason: primaryReason,
+        evidence: {
+            source: 'dashboard_export',
+            verification_plan_id: null,
+            changed_file_count: input.changedFileCount,
+            matched_intents: input.runnableIntentCount + input.skippedIntentCount,
+            ran_intents: 0,
+            passed_intents: 0,
+            failed_intents: latestRunFailed ? 1 : 0,
+            skipped_intents: input.skippedIntentCount,
+            receipt_count: input.latestRunExists && input.latestRunValid ? 1 : 0,
+            gap_count: input.gapCount,
+            source_anchor_risk_count: input.sourceAnchorRiskCount ?? 0,
+            scope_diff_risk_count: input.scopeDiffRiskCount ?? 0,
+            repeated_failure_count: input.repeatedFailureCount ?? 0,
+            validation_ratchet_risk_count: input.validationRatchetRiskCount ?? 0,
+            latest_run_status: input.latestRunStatus,
+        },
+        blockers,
+        contradictions,
+        limitations,
+    };
+}