mustflow 1.18.16 → 1.30.0

package/dist/cli/lib/local-index.js

@@ -14,6 +14,10 @@ const DEFAULT_DATABASE_RELATIVE_PATH = '.mustflow/cache/mustflow.sqlite';
 const LOCAL_INDEX_CONTENT_MODE = 'metadata_and_snippets';
 const LOCAL_INDEX_STORE_FULL_CONTENT = false;
 const MAX_SNIPPET_BYTES_PER_DOCUMENT = 2048;
+const MAX_SEARCH_MATCH_SNIPPET_CHARS = 240;
+const SEARCH_MATCH_CONTEXT_BEFORE_CHARS = 48;
+const SEARCH_MATCH_CONTEXT_AFTER_CHARS = 96;
+const SEARCH_MATCH_TRUNCATION_MARKER = '...';
 const SEARCH_NGRAM_MIN_LENGTH = 2;
 const SEARCH_NGRAM_MAX_LENGTH = 3;
 const SEARCH_BACKEND_FTS5 = 'fts5';
@@ -447,6 +451,9 @@ function splitIndexedList(value) {
 function createCommandEffectGraphStatus(databasePath, status, stalePaths = []) {
     return {
         source: 'local_index',
+        authority: 'explanation_only',
+        commandAuthority: '.mustflow/config/commands.toml',
+        grantsCommandAuthority: false,
         status,
         databasePath,
         indexFresh: status === 'fresh',
@@ -628,16 +635,22 @@ function getMatchSnippet(fields, query) {
     if (start === -1) {
         const [firstGram] = buildSearchNgrams([query]).filter((gram) => lower.includes(gram));
         if (!firstGram) {
-            return normalized.slice(0, 160);
+            return truncateSearchMatchSnippet(normalized);
         }
         start = lower.indexOf(firstGram);
         matchLength = firstGram.length;
     }
-    const from = Math.max(0, start - 48);
-    const to = Math.min(normalized.length, start + matchLength + 96);
-    const prefix = from > 0 ? '...' : '';
-    const suffix = to < normalized.length ? '...' : '';
-    return `${prefix}${normalized.slice(from, to)}${suffix}`;
+    const from = Math.max(0, start - SEARCH_MATCH_CONTEXT_BEFORE_CHARS);
+    const to = Math.min(normalized.length, start + matchLength + SEARCH_MATCH_CONTEXT_AFTER_CHARS);
+    const prefix = from > 0 ? SEARCH_MATCH_TRUNCATION_MARKER : '';
+    const suffix = to < normalized.length ? SEARCH_MATCH_TRUNCATION_MARKER : '';
+    return truncateSearchMatchSnippet(`${prefix}${normalized.slice(from, to)}${suffix}`);
+}
+function truncateSearchMatchSnippet(value) {
+    if (value.length <= MAX_SEARCH_MATCH_SNIPPET_CHARS) {
+        return value;
+    }
+    return `${value.slice(0, MAX_SEARCH_MATCH_SNIPPET_CHARS - SEARCH_MATCH_TRUNCATION_MARKER.length)}${SEARCH_MATCH_TRUNCATION_MARKER}`;
 }
 function scoreMatch(primaryFields, secondaryFields, query) {
     const lowerQuery = query.toLowerCase();
@@ -1397,6 +1410,9 @@ ORDER BY lock, left_intent, right_intent
 `, [intent, intent]).map((row) => mapCommandLockConflict(row, intent));
     return {
         source: 'local_index',
+        authority: 'explanation_only',
+        commandAuthority: '.mustflow/config/commands.toml',
+        grantsCommandAuthority: false,
         status: 'fresh',
         databasePath,
         indexFresh: true,

package/dist/cli/lib/run-plan.js

@@ -0,0 +1,222 @@
+import path from 'node:path';
+import { isMustflowBinName } from '../../core/command-classification.js';
+import { resolveSafeProjectCwd } from '../../core/command-cwd.js';
+import { resolveCommandEnv } from '../../core/command-env.js';
+import { evaluateCommandIntentEligibility, } from '../../core/command-intent-eligibility.js';
+import { isRecord, readPositiveInteger, readString, readStringArray, } from '../../core/config-loading.js';
+function getSuccessExitCodes(intent) {
+    const value = intent.success_exit_codes;
+    if (!Array.isArray(value) || value.length === 0 || value.some((entry) => !Number.isInteger(entry))) {
+        return [0];
+    }
+    return value.map(Number);
+}
+function readBoolean(intent, key) {
+    const value = intent[key];
+    return typeof value === 'boolean' ? value : undefined;
+}
+function readArray(intent, key) {
+    const value = intent[key];
+    return Array.isArray(value) ? value : undefined;
+}
+function toPosixPath(value) {
+    return value.split(path.sep).join('/');
+}
+function getRelativeProjectPath(projectRoot, targetPath) {
+    const relativePath = path.relative(projectRoot, targetPath);
+    return relativePath.length > 0 ? toPosixPath(relativePath) : '.';
+}
+function shouldUseShellForArgvExecutable(executablePath) {
+    return process.platform === 'win32' && executablePath.toLowerCase().endsWith('.cmd');
+}
+export function isMustflowBuiltinIntent(intent) {
+    return readString(intent, 'kind') === 'mustflow_builtin';
+}
+function resolveCurrentCliEntrypoint() {
+    const entrypoint = process.argv[1];
+    return entrypoint ? path.resolve(entrypoint) : undefined;
+}
+function resolveArgvCommand(intent, commandArgv) {
+    const [command = '', ...args] = commandArgv;
+    if (isMustflowBuiltinIntent(intent) && isMustflowBinName(command)) {
+        const entrypoint = resolveCurrentCliEntrypoint();
+        if (entrypoint) {
+            return {
+                executable: process.execPath,
+                args: [entrypoint, ...args],
+                shell: false,
+            };
+        }
+    }
+    return {
+        executable: command,
+        args,
+        shell: shouldUseShellForArgvExecutable(command),
+    };
+}
+function getRunPlanMode(commandArgv, intent) {
+    if (commandArgv) {
+        return 'argv';
+    }
+    return intent.mode === 'shell' ? 'shell' : null;
+}
+function readRunIntentMetadata(contract, intent) {
+    const configuredCwd = readString(intent, 'cwd') ?? readString(contract.defaults, 'default_cwd') ?? '.';
+    const commandArgv = readStringArray(intent, 'argv');
+    const shellCommand = intent.mode === 'shell' ? readString(intent, 'cmd') : undefined;
+    const env = resolveCommandEnv(contract, intent);
+    return {
+        intentStatus: readString(intent, 'status') ?? 'unknown',
+        lifecycle: readString(intent, 'lifecycle') ?? null,
+        runPolicy: readString(intent, 'run_policy') ?? null,
+        kind: readString(intent, 'kind') ?? null,
+        configuredCwd,
+        timeoutSeconds: readPositiveInteger(intent, 'timeout_seconds') ?? null,
+        maxOutputBytes: readPositiveInteger(intent, 'max_output_bytes') ?? readPositiveInteger(contract.defaults, 'max_output_bytes') ?? 1_048_576,
+        successExitCodes: getSuccessExitCodes(intent),
+        commandArgv,
+        shellCommand,
+        mode: getRunPlanMode(commandArgv, intent),
+        writes: readStringArray(intent, 'writes'),
+        effects: readArray(intent, 'effects'),
+        network: readBoolean(intent, 'network'),
+        destructive: readBoolean(intent, 'destructive'),
+        envPolicy: env.policy,
+        envAllowlist: env.allowlist,
+    };
+}
+function createBlockedRunPlan(contract, intentName, intent, eligibility, reasonCode, detail) {
+    const metadata = intent ? readRunIntentMetadata(contract, intent) : null;
+    return {
+        intentName,
+        intent,
+        ok: false,
+        eligibility,
+        reasonCode,
+        detail,
+        intentStatus: metadata?.intentStatus ?? null,
+        lifecycle: metadata?.lifecycle ?? null,
+        runPolicy: metadata?.runPolicy ?? null,
+        kind: metadata?.kind ?? null,
+        configuredCwd: metadata?.configuredCwd ?? null,
+        cwd: null,
+        relativeCwd: null,
+        timeoutSeconds: metadata?.timeoutSeconds ?? null,
+        maxOutputBytes: metadata?.maxOutputBytes ?? null,
+        successExitCodes: metadata?.successExitCodes ?? null,
+        commandArgv: metadata?.commandArgv,
+        shellCommand: metadata?.shellCommand,
+        mode: metadata?.mode ?? null,
+        argvCommand: undefined,
+        writes: metadata?.writes,
+        effects: metadata?.effects,
+        network: metadata?.network,
+        destructive: metadata?.destructive,
+        envPolicy: metadata?.envPolicy ?? null,
+        envAllowlist: metadata?.envAllowlist ?? [],
+    };
+}
+export function createRunPlan(projectRoot, contract, intentName) {
+    const rawIntent = contract.intents[intentName];
+    const eligibility = evaluateCommandIntentEligibility(intentName, rawIntent);
+    if (!isRecord(rawIntent)) {
+        return createBlockedRunPlan(contract, intentName, undefined, eligibility, 'intent_not_table', eligibility.detail);
+    }
+    if (!eligibility.ok) {
+        return createBlockedRunPlan(contract, intentName, rawIntent, eligibility, eligibility.code, eligibility.detail);
+    }
+    const metadata = readRunIntentMetadata(contract, rawIntent);
+    let cwd;
+    try {
+        cwd = resolveSafeProjectCwd(projectRoot, metadata.configuredCwd);
+    }
+    catch (error) {
+        return createBlockedRunPlan(contract, intentName, rawIntent, eligibility, 'cwd_outside_project', error instanceof Error ? error.message : String(error));
+    }
+    if (!metadata.timeoutSeconds || !metadata.mode) {
+        return createBlockedRunPlan(contract, intentName, rawIntent, eligibility, !metadata.timeoutSeconds ? 'missing_timeout' : 'missing_command_source', !metadata.timeoutSeconds ? 'Intent timeout_seconds is missing or invalid.' : 'Intent does not define argv or shell cmd.');
+    }
+    return {
+        intentName,
+        intent: rawIntent,
+        ok: true,
+        eligibility,
+        reasonCode: null,
+        detail: null,
+        intentStatus: metadata.intentStatus,
+        lifecycle: metadata.lifecycle,
+        runPolicy: metadata.runPolicy,
+        kind: metadata.kind,
+        configuredCwd: metadata.configuredCwd,
+        cwd,
+        relativeCwd: getRelativeProjectPath(projectRoot, cwd),
+        timeoutSeconds: metadata.timeoutSeconds,
+        maxOutputBytes: metadata.maxOutputBytes,
+        successExitCodes: metadata.successExitCodes,
+        commandArgv: metadata.commandArgv,
+        shellCommand: metadata.shellCommand,
+        mode: metadata.mode,
+        argvCommand: metadata.commandArgv ? resolveArgvCommand(rawIntent, metadata.commandArgv) : undefined,
+        writes: metadata.writes,
+        effects: metadata.effects,
+        network: metadata.network,
+        destructive: metadata.destructive,
+        envPolicy: metadata.envPolicy,
+        envAllowlist: metadata.envAllowlist,
+    };
+}
+export function createRunPreview(plan, previewMode) {
+    return {
+        schema_version: '1',
+        command: 'run',
+        preview: true,
+        preview_mode: previewMode,
+        intent: plan.intentName,
+        runnable: plan.ok,
+        eligibility: plan.eligibility,
+        reason_code: plan.reasonCode,
+        detail: plan.detail,
+        status: plan.intentStatus,
+        lifecycle: plan.lifecycle,
+        run_policy: plan.runPolicy,
+        kind: plan.kind,
+        configured_cwd: plan.configuredCwd,
+        cwd: plan.relativeCwd,
+        resolved_cwd: plan.cwd,
+        timeout_seconds: plan.timeoutSeconds,
+        max_output_bytes: plan.maxOutputBytes,
+        mode: plan.mode,
+        argv: plan.commandArgv,
+        resolved_argv: plan.argvCommand,
+        cmd: plan.shellCommand,
+        writes: plan.writes,
+        effects: plan.effects,
+        network: plan.network,
+        destructive: plan.destructive,
+        env_policy: plan.envPolicy,
+        env_allowlist: plan.envAllowlist,
+        success_exit_codes: plan.successExitCodes,
+    };
+}
+export function renderRunPreviewText(plan, previewMode) {
+    const lines = [
+        `mf run ${previewMode}`,
+        `Intent: ${plan.intentName}`,
+        `Runnable: ${plan.ok ? 'yes' : 'no'}`,
+    ];
+    if (!plan.ok) {
+        lines.push(`Reason: ${plan.reasonCode}${plan.detail ? ` (${plan.detail})` : ''}`);
+        return lines.join('\n');
+    }
+    lines.push(`Mode: ${plan.mode}`);
+    lines.push(`Cwd: ${plan.relativeCwd}`);
+    lines.push(`Timeout: ${plan.timeoutSeconds}s`);
+    lines.push(`Environment: ${plan.envPolicy}${plan.envAllowlist.length > 0 ? ` (${plan.envAllowlist.join(', ')})` : ''}`);
+    if (plan.commandArgv) {
+        lines.push(`Argv: ${plan.commandArgv.join(' ')}`);
+    }
+    else if (plan.shellCommand) {
+        lines.push(`Shell: ${plan.shellCommand}`);
+    }
+    return lines.join('\n');
+}

package/dist/cli/lib/templates.js

@@ -163,17 +163,32 @@ export function getDefaultTemplate() {
 export function getTemplateFiles(template, locale = template.manifest.defaultLocale, profile = template.manifest.defaultProfile, options = {}) {
     const commonRoot = path.join(template.templateRoot, template.manifest.commonRoot);
     const localeRoot = template.manifest.localesRoot ? path.join(template.templateRoot, template.manifest.localesRoot, locale) : undefined;
+    const sourceLocaleRoot = template.manifest.localesRoot && locale !== template.manifest.defaultLocale
+        ? path.join(template.templateRoot, template.manifest.localesRoot, template.manifest.defaultLocale)
+        : undefined;
     const selectedSkills = selectedSkillNames(template.manifest, profile, options);
     return template.manifest.creates.filter((relativePath) => shouldIncludeTemplatePath(relativePath, selectedSkills)).map((relativePath) => {
         const localePath = localeRoot ? path.join(localeRoot, ...relativePath.split('/')) : undefined;
+        const sourceLocalePath = sourceLocaleRoot ? path.join(sourceLocaleRoot, ...relativePath.split('/')) : undefined;
         const commonPath = path.join(commonRoot, ...relativePath.split('/'));
+        const localizedPath = localePath && existsSync(localePath) ? localePath : undefined;
+        const fallbackLocalePath = sourceLocalePath && existsSync(sourceLocalePath) ? sourceLocalePath : undefined;
+        const indexSourcePath = localizedPath ?? fallbackLocalePath ?? commonPath;
         const content = relativePath === '.mustflow/skills/INDEX.md'
-            ? filterSkillIndexContent(readFileSync(localePath && existsSync(localePath) ? localePath : commonPath, 'utf8'), selectedSkills)
+            ? filterSkillIndexContent(readFileSync(indexSourcePath, 'utf8'), selectedSkills)
             : undefined;
-        if (localePath && existsSync(localePath)) {
+        if (localizedPath) {
             return {
                 relativePath,
-                sourcePath: localePath,
+                sourcePath: localizedPath,
+                sourceKind: 'locale',
+                content,
+            };
+        }
+        if (fallbackLocalePath) {
+            return {
+                relativePath,
+                sourcePath: fallbackLocalePath,
                 sourceKind: 'locale',
                 content,
             };

package/dist/cli/lib/update-diff-preview.js

@@ -0,0 +1,163 @@
+import { existsSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import { ensureFileTargetInsideWithoutSymlinks, readUtf8FileInsideWithoutSymlinks } from './filesystem.js';
+const DIFF_PREVIEW_MAX_LINES = 120;
+const DIFF_PREVIEW_MAX_LINE_BYTES = 240;
+const DIFF_PREVIEW_CONTEXT_LINES = 3;
+const DIFF_PREVIEW_TRUNCATION_MARKER = '[... diff preview truncated ...]';
+const DIFF_PREVIEW_LINE_TRUNCATION_MARKER = ' [... line truncated]';
+export function shouldPreviewUpdateDiff(action) {
+    return action === 'create' || action === 'update' || action === 'blocked-local-change' || action === 'manual-review';
+}
+function templateFileContent(source) {
+    return source.content === undefined ? readFileSync(source.sourcePath, 'utf8') : source.content;
+}
+function shouldOmitDiffPreview(relativePath) {
+    const normalizedPath = relativePath.replaceAll('\\', '/');
+    const lowerPath = normalizedPath.toLowerCase();
+    return (normalizedPath.startsWith('.mustflow/state/') ||
+        normalizedPath.startsWith('.mustflow/cache/') ||
+        normalizedPath.startsWith('.mustflow/backups/') ||
+        lowerPath === '.env' ||
+        lowerPath.startsWith('.env.') ||
+        lowerPath.endsWith('.pem') ||
+        lowerPath.endsWith('.key'));
+}
+function unavailableDiffPreview(reason) {
+    return {
+        format: 'unified',
+        available: false,
+        from: 'unavailable',
+        to: 'bundled_template',
+        bounded: true,
+        truncated: false,
+        max_lines: DIFF_PREVIEW_MAX_LINES,
+        max_line_bytes: DIFF_PREVIEW_MAX_LINE_BYTES,
+        lines: [],
+        reason,
+    };
+}
+function splitDiffLines(content) {
+    const normalized = content.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+    if (normalized.length === 0) {
+        return [];
+    }
+    return normalized.endsWith('\n') ? normalized.slice(0, -1).split('\n') : normalized.split('\n');
+}
+function unifiedRange(startIndex, count) {
+    if (count === 0) {
+        return `${startIndex},0`;
+    }
+    return `${startIndex + 1},${count}`;
+}
+function truncateDiffLine(line) {
+    if (Buffer.byteLength(line, 'utf8') <= DIFF_PREVIEW_MAX_LINE_BYTES) {
+        return { line, truncated: false };
+    }
+    let result = '';
+    for (const character of line) {
+        const candidate = `${result}${character}${DIFF_PREVIEW_LINE_TRUNCATION_MARKER}`;
+        if (Buffer.byteLength(candidate, 'utf8') > DIFF_PREVIEW_MAX_LINE_BYTES) {
+            break;
+        }
+        result += character;
+    }
+    return {
+        line: `${result}${DIFF_PREVIEW_LINE_TRUNCATION_MARKER}`,
+        truncated: true,
+    };
+}
+function boundDiffLines(lines) {
+    const bounded = [];
+    let truncated = false;
+    for (const line of lines) {
+        if (bounded.length >= DIFF_PREVIEW_MAX_LINES) {
+            truncated = true;
+            break;
+        }
+        const boundedLine = truncateDiffLine(line);
+        truncated = truncated || boundedLine.truncated;
+        bounded.push(boundedLine.line);
+    }
+    if (truncated) {
+        if (bounded.length >= DIFF_PREVIEW_MAX_LINES) {
+            bounded[bounded.length - 1] = DIFF_PREVIEW_TRUNCATION_MARKER;
+        }
+        else {
+            bounded.push(DIFF_PREVIEW_TRUNCATION_MARKER);
+        }
+    }
+    return { lines: bounded, truncated };
+}
+function createUnifiedDiffLines(relativePath, currentContent, templateContent, targetExists) {
+    const currentLines = splitDiffLines(currentContent);
+    const templateLines = splitDiffLines(templateContent);
+    let prefixLength = 0;
+    while (prefixLength < currentLines.length &&
+        prefixLength < templateLines.length &&
+        currentLines[prefixLength] === templateLines[prefixLength]) {
+        prefixLength += 1;
+    }
+    let suffixLength = 0;
+    while (suffixLength < currentLines.length - prefixLength &&
+        suffixLength < templateLines.length - prefixLength &&
+        currentLines[currentLines.length - 1 - suffixLength] === templateLines[templateLines.length - 1 - suffixLength]) {
+        suffixLength += 1;
+    }
+    const currentChangeEnd = currentLines.length - suffixLength;
+    const templateChangeEnd = templateLines.length - suffixLength;
+    const currentStart = Math.max(0, prefixLength - DIFF_PREVIEW_CONTEXT_LINES);
+    const templateStart = Math.max(0, prefixLength - DIFF_PREVIEW_CONTEXT_LINES);
+    const currentEnd = Math.min(currentLines.length, currentChangeEnd + DIFF_PREVIEW_CONTEXT_LINES);
+    const templateEnd = Math.min(templateLines.length, templateChangeEnd + DIFF_PREVIEW_CONTEXT_LINES);
+    const lines = [
+        targetExists ? `--- ${relativePath} (current)` : '--- /dev/null',
+        `+++ ${relativePath} (template)`,
+        `@@ -${unifiedRange(currentStart, currentEnd - currentStart)} +${unifiedRange(templateStart, templateEnd - templateStart)} @@`,
+    ];
+    for (let index = currentStart; index < prefixLength; index += 1) {
+        lines.push(` ${currentLines[index]}`);
+    }
+    for (let index = prefixLength; index < currentChangeEnd; index += 1) {
+        lines.push(`-${currentLines[index]}`);
+    }
+    for (let index = prefixLength; index < templateChangeEnd; index += 1) {
+        lines.push(`+${templateLines[index]}`);
+    }
+    for (let index = currentChangeEnd; index < currentEnd; index += 1) {
+        lines.push(` ${currentLines[index]}`);
+    }
+    return lines;
+}
+export function createUpdateDiffPreview(projectRoot, input) {
+    if (shouldOmitDiffPreview(input.relativePath)) {
+        return unavailableDiffPreview('diff preview omitted for generated state, cache, backup, or sensitive-looking path');
+    }
+    const targetPath = path.join(projectRoot, input.relativePath);
+    const targetExists = existsSync(targetPath);
+    try {
+        if (targetExists) {
+            ensureFileTargetInsideWithoutSymlinks(projectRoot, targetPath);
+        }
+        else {
+            ensureFileTargetInsideWithoutSymlinks(projectRoot, targetPath, { allowMissingLeaf: true });
+        }
+        const currentContent = targetExists ? readUtf8FileInsideWithoutSymlinks(projectRoot, targetPath) : '';
+        const templateContent = templateFileContent(input.source);
+        const boundedLines = boundDiffLines(createUnifiedDiffLines(input.relativePath, currentContent, templateContent, targetExists));
+        return {
+            format: 'unified',
+            available: true,
+            from: targetExists ? 'current_target' : 'missing_target',
+            to: 'bundled_template',
+            bounded: true,
+            truncated: boundedLines.truncated,
+            max_lines: DIFF_PREVIEW_MAX_LINES,
+            max_line_bytes: DIFF_PREVIEW_MAX_LINE_BYTES,
+            lines: boundedLines.lines,
+        };
+    }
+    catch (error) {
+        return unavailableDiffPreview(error instanceof Error ? error.message : String(error));
+    }
+}

package/dist/cli/lib/validation.js

@@ -13,6 +13,7 @@ import { inspectManifestLock } from './manifest-lock.js';
 import { COMMIT_MESSAGE_STYLES, TEST_AUTHORING_POLICIES } from './preferences-options.js';
 import { generateRepoMap } from './repo-map.js';
 import { readTomlFile } from './toml.js';
+import { getContractModelDefinitions, validateCandidateContractModelConfig, } from '../../core/contract-models.js';
 import { VERSIONING_CONFIG_PATH, VERSION_SOURCE_AUTHORITIES, VERSION_SOURCE_KINDS, detectVersionSourcePaths, readDeclaredVersionSources, releaseVersioningIsEnabled, } from '../../core/version-sources.js';
 export { describeCheckIssues, getCheckIssueId, } from '../../core/check-issues.js';
 const REQUIRED_SKILL_SECTION_IDS = [
@@ -1222,6 +1223,26 @@ function validateStrictVerificationSelectionAuthority(preferencesToml, issues) {
         }
     }
 }
+function validateStrictCandidateContractModelConfigs(projectRoot, issues) {
+    for (const model of getContractModelDefinitions()) {
+        const configPath = path.join(projectRoot, ...model.filePath.split('/'));
+        if (!existsSync(configPath)) {
+            continue;
+        }
+        let parsed;
+        try {
+            parsed = readTomlFile(configPath);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            pushStrictIssue(issues, `Invalid TOML in ${model.filePath}: ${message}`);
+            continue;
+        }
+        for (const issue of validateCandidateContractModelConfig(model, parsed)) {
+            pushStrictIssue(issues, issue.message);
+        }
+    }
+}
 function validateStrictReleaseVersioningAuthority(preferencesToml, issues) {
     if (!preferencesToml || !isRecord(preferencesToml.release)) {
         return;
@@ -1597,6 +1618,7 @@ function validateStrict(projectRoot, parsed, issues) {
     validateStrictCommandDefaults(projectRoot, parsed.commandsToml, issues);
     validateStrictReleaseVersioningAuthority(parsed.preferencesToml, issues);
     validateStrictVerificationSelectionAuthority(parsed.preferencesToml, issues);
+    validateStrictCandidateContractModelConfigs(projectRoot, issues);
     validateStrictVersionSources(projectRoot, parsed.preferencesToml, parsed.versioningToml, issues);
     validateStrictTemplateVersionSync(projectRoot, parsed.preferencesToml, issues);
     validateStrictManagedMarkdownIdentities(projectRoot, issues);