mustflow 2.28.0 → 2.29.0

package/dist/cli/commands/context.js

@@ -77,6 +77,7 @@ export async function runContext(args, reporter, lang = 'en') {
     reporter.stdout(`${t(lang, 'label.mustflowRoot')}: ${context.mustflow_root}`);
     reporter.stdout(`${t(lang, 'label.commandContract')}: ${context.command_contract.exists ? t(lang, 'value.present') : t(lang, 'value.missing')}`);
     reporter.stdout(`${t(lang, 'label.runnableIntents')}: ${context.command_contract.runnable_intents.length}`);
+    reporter.stdout(`Technology preferences: ${context.technology_preferences.exists ? t(lang, 'value.present') : t(lang, 'value.missing')} (${context.technology_preferences.count})`);
     reporter.stdout(`${t(lang, 'label.latestRun')}: ${context.latest_run.exists ? t(lang, 'value.present') : t(lang, 'value.missing')}`);
     return 0;
 }

package/dist/cli/commands/help.js

@@ -4,6 +4,7 @@ import { t } from '../lib/i18n.js';
 import { readMustflowTextFileIfExists } from '../lib/mustflow-read.js';
 import { resolveMustflowRoot } from '../lib/project-root.js';
 import { readMustflowTomlFile } from '../lib/toml.js';
+import { normalizeTechnologyPreferencesTable, TECHNOLOGY_CONFIG_RELATIVE_PATH, } from '../../core/technology-preferences.js';
 function readTextIfExists(projectRoot, relativePath) {
     return readMustflowTextFileIfExists(projectRoot, relativePath) ?? undefined;
 }
@@ -58,6 +59,51 @@ function renderPreferencesHelp(projectRoot, lang) {
     }
     return lines.join('\n').trimEnd();
 }
+function renderTechnologyPreference(preference) {
+    const details = [
+        preference.scope.length > 0 ? `scope: ${preference.scope.join(', ')}` : null,
+        preference.ecosystem ? `ecosystem: ${preference.ecosystem}` : null,
+        preference.packages.length > 0 ? `packages: ${preference.packages.join(', ')}` : null,
+    ].filter((value) => value !== null);
+    const lines = [`- [${preference.status}] ${preference.kind} ${preference.name} (${preference.id})`];
+    if (details.length > 0) {
+        lines.push(`  ${details.join('; ')}`);
+    }
+    if (preference.rationale) {
+        lines.push(`  why: ${preference.rationale}`);
+    }
+    for (const constraint of preference.constraints) {
+        lines.push(`  constraint: ${constraint}`);
+    }
+    return lines;
+}
+function renderTechnologyHelp(projectRoot, lang) {
+    const technology = readTomlIfExists(projectRoot, TECHNOLOGY_CONFIG_RELATIVE_PATH);
+    if (!technology) {
+        return `Technology Preferences\n\n${renderMissing(TECHNOLOGY_CONFIG_RELATIVE_PATH, lang)}`;
+    }
+    const file = normalizeTechnologyPreferencesTable(technology, true);
+    const lines = [
+        'Technology Preferences',
+        '',
+        `Path: ${file.path}`,
+        `Authority: ${file.authority} (preferences only)`,
+        'Guidance:',
+        ...file.guidance.map((item) => `- ${item}`),
+        '',
+        `Preferences: ${file.preferences.length}`,
+    ];
+    if (file.preferences.length === 0) {
+        lines.push('No technology preferences recorded.');
+    }
+    for (const preference of file.preferences) {
+        lines.push(...renderTechnologyPreference(preference));
+    }
+    if (file.issues.length > 0) {
+        lines.push('', 'Issues:', ...file.issues.map((issue) => `- ${issue}`));
+    }
+    return lines.join('\n');
+}
 function renderPreferenceSection(lines, sectionName, section) {
     const nestedSections = [];
     const scalarLines = [];
@@ -97,9 +143,13 @@ export function getHelpHelp(lang = 'en') {
                 label: 'preferences',
                 description: t(lang, 'help.topic.preferences'),
             },
+            {
+                label: 'technology',
+                description: 'Show framework, library, runtime, and tool preferences',
+            },
         ],
         options: [{ label: '-h, --help', description: t(lang, 'cli.option.help') }],
-        examples: ['mf help workflow', 'mf help skills', 'mf help preferences'],
+        examples: ['mf help workflow', 'mf help skills', 'mf help preferences', 'mf help technology'],
         exitCodes: [
             {
                 label: '0',
@@ -139,6 +189,10 @@ export function runHelp(args, reporter, lang = 'en') {
         reporter.stdout(renderPreferencesHelp(projectRoot, lang));
         return 0;
     }
+    if (topic === 'technology') {
+        reporter.stdout(renderTechnologyHelp(projectRoot, lang));
+        return 0;
+    }
     reporter.stderr(renderCliError(t(lang, 'help.error.unknownTopic', { topic }), 'mf help --help', lang));
     return 1;
 }

package/dist/cli/commands/tech.js

@@ -0,0 +1,346 @@
+import path from 'node:path';
+import { printUsageError, renderCliError, renderHelp } from '../lib/cli-output.js';
+import { writeUtf8FileInsideWithoutSymlinks } from '../lib/filesystem.js';
+import { isRecord } from '../lib/command-contract.js';
+import { t } from '../lib/i18n.js';
+import { formatCliOptionParseError, getParsedCliStringOption, hasCliOptionToken, hasParsedCliOption, parseCliOptions, } from '../lib/option-parser.js';
+import { resolveMustflowRoot } from '../lib/project-root.js';
+import { readMustflowTomlFile } from '../lib/toml.js';
+import { createTechnologyPreferenceId, normalizeTechnologyKey, normalizeTechnologyName, normalizeTechnologyPreferencesTable, serializeTechnologyPreferences, technologyConfigExists, technologyPreferenceMatches, TECHNOLOGY_AUTHORITY, TECHNOLOGY_CONFIG_RELATIVE_PATH, TECHNOLOGY_GUIDANCE, TECHNOLOGY_KINDS, TECHNOLOGY_STATUSES, } from '../../core/technology-preferences.js';
+const TECH_OPTIONS = [
+    { name: '--json', kind: 'boolean' },
+    { name: '--scope', kind: 'string' },
+    { name: '--kind', kind: 'string' },
+    { name: '--status', kind: 'string' },
+    { name: '--ecosystem', kind: 'string' },
+    { name: '--package', kind: 'string' },
+    { name: '--why', kind: 'string' },
+    { name: '--constraint', kind: 'string' },
+];
+function getRepeatedStringOptions(occurrences, name) {
+    return occurrences
+        .filter((occurrence) => occurrence.name === name && typeof occurrence.value === 'string')
+        .map((occurrence) => String(occurrence.value).trim())
+        .filter((value) => value.length > 0);
+}
+function isTechnologyKind(value) {
+    return value !== null && TECHNOLOGY_KINDS.includes(value);
+}
+function isTechnologyStatus(value) {
+    return value !== null && TECHNOLOGY_STATUSES.includes(value);
+}
+export function getTechHelp(lang = 'en') {
+    return renderHelp({
+        usage: 'mf tech <list|add|remove|suggest> [options]',
+        summary: 'Manage low-authority technology preferences for agents.',
+        options: [
+            { label: '--json', description: t(lang, 'cli.option.json') },
+            { label: '--scope <scope>', description: 'Filter or tag a project area such as frontend, backend, ui, data, or cli' },
+            { label: '--kind <kind>', description: `Technology kind: ${TECHNOLOGY_KINDS.join(', ')}` },
+            { label: '--status <status>', description: `Preference status: ${TECHNOLOGY_STATUSES.join(', ')}` },
+            { label: '--ecosystem <ecosystem>', description: 'Package ecosystem or platform, such as npm, cargo, pip, go, or deno' },
+            { label: '--package <package>', description: 'Package name to associate with the preference. Repeatable.' },
+            { label: '--why <text>', description: 'Short rationale for the preference' },
+            { label: '--constraint <text>', description: 'Guardrail agents must keep in mind. Repeatable.' },
+            { label: '-h, --help', description: t(lang, 'cli.option.help') },
+        ],
+        examples: [
+            'mf tech list',
+            'mf tech add framework nextjs --scope frontend --ecosystem npm --package next --package react --why "Preferred React app framework"',
+            'mf tech add language rust --scope backend --status preferred --why "Use for correctness-critical engines"',
+            'mf tech add library jquery --scope frontend --status avoid --why "Avoid new usage"',
+            'mf tech suggest --scope frontend',
+            'mf tech remove framework.frontend.nextjs',
+        ],
+        exitCodes: [
+            { label: '0', description: 'Technology preferences were inspected or updated' },
+            { label: '1', description: t(lang, 'cli.common.invalidInput') },
+        ],
+    }, lang);
+}
+function parseTechOptions(args, lang) {
+    const [actionToken, ...rest] = args;
+    const action = actionToken;
+    if (action !== 'list' && action !== 'add' && action !== 'remove' && action !== 'suggest') {
+        return {
+            action: 'list',
+            positionals: [],
+            json: false,
+            scope: [],
+            kind: null,
+            status: null,
+            ecosystem: null,
+            packages: [],
+            why: null,
+            constraints: [],
+            error: actionToken ? `Unknown tech action: ${actionToken}` : 'Specify a tech action: list, add, remove, or suggest',
+        };
+    }
+    const parsed = parseCliOptions(rest, TECH_OPTIONS, { allowPositionals: true });
+    if (parsed.error) {
+        return {
+            action,
+            positionals: parsed.positionals,
+            json: hasParsedCliOption(parsed, '--json'),
+            scope: [],
+            kind: null,
+            status: null,
+            ecosystem: null,
+            packages: [],
+            why: null,
+            constraints: [],
+            error: formatCliOptionParseError(parsed.error, lang),
+        };
+    }
+    const kind = getParsedCliStringOption(parsed, '--kind');
+    const status = getParsedCliStringOption(parsed, '--status');
+    if (kind !== null && !isTechnologyKind(kind)) {
+        return invalidParsed(action, parsed.positionals, hasParsedCliOption(parsed, '--json'), `Unsupported technology kind: ${kind}`);
+    }
+    if (status !== null && !isTechnologyStatus(status)) {
+        return invalidParsed(action, parsed.positionals, hasParsedCliOption(parsed, '--json'), `Unsupported technology status: ${status}`);
+    }
+    return {
+        action,
+        positionals: parsed.positionals,
+        json: hasParsedCliOption(parsed, '--json'),
+        scope: getRepeatedStringOptions(parsed.occurrences, '--scope'),
+        kind,
+        status,
+        ecosystem: getParsedCliStringOption(parsed, '--ecosystem'),
+        packages: getRepeatedStringOptions(parsed.occurrences, '--package'),
+        why: getParsedCliStringOption(parsed, '--why'),
+        constraints: getRepeatedStringOptions(parsed.occurrences, '--constraint'),
+    };
+}
+function invalidParsed(action, positionals, json, error) {
+    return {
+        action,
+        positionals,
+        json,
+        scope: [],
+        kind: null,
+        status: null,
+        ecosystem: null,
+        packages: [],
+        why: null,
+        constraints: [],
+        error,
+    };
+}
+function readTechnologyPreferences(projectRoot) {
+    if (!technologyConfigExists(projectRoot)) {
+        return normalizeTechnologyPreferencesTable(undefined, false);
+    }
+    const parsed = readMustflowTomlFile(projectRoot, TECHNOLOGY_CONFIG_RELATIVE_PATH);
+    if (!isRecord(parsed)) {
+        return {
+            ...normalizeTechnologyPreferencesTable(undefined, true),
+            issues: [`${TECHNOLOGY_CONFIG_RELATIVE_PATH} must contain a TOML table`],
+        };
+    }
+    return normalizeTechnologyPreferencesTable(parsed, true);
+}
+function writeTechnologyPreferences(projectRoot, preferences) {
+    const targetPath = path.join(projectRoot, ...TECHNOLOGY_CONFIG_RELATIVE_PATH.split('/'));
+    writeUtf8FileInsideWithoutSymlinks(projectRoot, targetPath, serializeTechnologyPreferences(preferences));
+}
+function renderPreference(preference) {
+    const details = [
+        preference.scope.length > 0 ? `scope: ${preference.scope.join(', ')}` : null,
+        preference.ecosystem ? `ecosystem: ${preference.ecosystem}` : null,
+        preference.packages.length > 0 ? `packages: ${preference.packages.join(', ')}` : null,
+    ].filter((value) => value !== null);
+    const lines = [`- [${preference.status}] ${preference.kind} ${preference.name} (${preference.id})`];
+    if (details.length > 0) {
+        lines.push(`  ${details.join('; ')}`);
+    }
+    if (preference.rationale) {
+        lines.push(`  why: ${preference.rationale}`);
+    }
+    for (const constraint of preference.constraints) {
+        lines.push(`  constraint: ${constraint}`);
+    }
+    return lines;
+}
+function renderList(file, preferences) {
+    const lines = [
+        'mustflow technology preferences',
+        `Path: ${file.path}`,
+        `Authority: ${file.authority} (preferences only)`,
+        `Preferences: ${preferences.length}`,
+    ];
+    if (file.issues.length > 0) {
+        lines.push('Issues:', ...file.issues.map((issue) => `- ${issue}`));
+    }
+    if (preferences.length === 0) {
+        lines.push('No technology preferences recorded.');
+        return lines.join('\n');
+    }
+    for (const preference of preferences) {
+        lines.push(...renderPreference(preference));
+    }
+    return lines.join('\n');
+}
+function filterPreferences(file, options) {
+    return file.preferences.filter((preference) => technologyPreferenceMatches(preference, {
+        scope: options.scope[0] ?? null,
+        kind: options.kind,
+        status: options.status,
+    }));
+}
+function runList(projectRoot, options, reporter) {
+    const file = readTechnologyPreferences(projectRoot);
+    const preferences = filterPreferences(file, options);
+    if (options.json) {
+        reporter.stdout(JSON.stringify({ ...file, preferences }, null, 2));
+        return file.issues.length === 0 ? 0 : 1;
+    }
+    reporter.stdout(renderList(file, preferences));
+    return file.issues.length === 0 ? 0 : 1;
+}
+function runSuggest(projectRoot, options, reporter) {
+    const file = readTechnologyPreferences(projectRoot);
+    const filtered = filterPreferences(file, {
+        ...options,
+        status: null,
+    });
+    const preferred = filtered.filter((preference) => preference.status === 'preferred' || preference.status === 'allowed');
+    const avoid = filtered.filter((preference) => preference.status === 'avoid');
+    const payload = {
+        path: file.path,
+        authority: TECHNOLOGY_AUTHORITY,
+        guidance: TECHNOLOGY_GUIDANCE,
+        preferred,
+        avoid,
+        issues: file.issues,
+    };
+    if (options.json) {
+        reporter.stdout(JSON.stringify(payload, null, 2));
+        return file.issues.length === 0 ? 0 : 1;
+    }
+    const lines = ['mustflow technology suggestions', `Path: ${file.path}`, `Authority: ${TECHNOLOGY_AUTHORITY}`];
+    lines.push('Guidance:', ...TECHNOLOGY_GUIDANCE.map((item) => `- ${item}`));
+    lines.push('Preferred or allowed:');
+    lines.push(...(preferred.length === 0 ? ['- none'] : preferred.flatMap(renderPreference)));
+    lines.push('Avoid:');
+    lines.push(...(avoid.length === 0 ? ['- none'] : avoid.flatMap(renderPreference)));
+    if (file.issues.length > 0) {
+        lines.push('Issues:', ...file.issues.map((issue) => `- ${issue}`));
+    }
+    reporter.stdout(lines.join('\n'));
+    return file.issues.length === 0 ? 0 : 1;
+}
+function findExistingIndex(preferences, candidate) {
+    return preferences.findIndex((preference) => {
+        if (preference.id === candidate.id) {
+            return true;
+        }
+        return preference.kind === candidate.kind && normalizeTechnologyKey(preference.name) === normalizeTechnologyKey(candidate.name);
+    });
+}
+function runAdd(projectRoot, options, reporter) {
+    const [kindToken, nameToken] = options.positionals;
+    if (!isTechnologyKind(kindToken ?? null)) {
+        reporter.stderr(renderCliError('Missing or unsupported technology kind', 'mf tech --help'));
+        return 1;
+    }
+    if (!nameToken) {
+        reporter.stderr(renderCliError('Missing technology name', 'mf tech --help'));
+        return 1;
+    }
+    const kind = kindToken;
+    if (options.status !== null && !isTechnologyStatus(options.status)) {
+        reporter.stderr(renderCliError(`Unsupported technology status: ${options.status}`, 'mf tech --help'));
+        return 1;
+    }
+    const file = readTechnologyPreferences(projectRoot);
+    if (file.issues.length > 0) {
+        reporter.stderr(renderCliError(`Cannot update invalid ${TECHNOLOGY_CONFIG_RELATIVE_PATH}`, 'mf tech list'));
+        return 1;
+    }
+    const status = options.status ?? 'preferred';
+    const scope = options.scope.length > 0 ? options.scope : [];
+    const name = normalizeTechnologyName(nameToken);
+    const candidate = {
+        id: createTechnologyPreferenceId(kind, name, scope),
+        kind,
+        name,
+        status,
+        authority: TECHNOLOGY_AUTHORITY,
+        scope,
+        ecosystem: options.ecosystem,
+        packages: options.packages,
+        rationale: options.why,
+        constraints: options.constraints,
+    };
+    const preferences = [...file.preferences];
+    const existingIndex = findExistingIndex(preferences, candidate);
+    const action = existingIndex === -1 ? 'created' : 'updated';
+    if (existingIndex === -1) {
+        preferences.push(candidate);
+    }
+    else {
+        preferences[existingIndex] = candidate;
+    }
+    writeTechnologyPreferences(projectRoot, preferences);
+    if (options.json) {
+        reporter.stdout(JSON.stringify({ action, preference: candidate, path: TECHNOLOGY_CONFIG_RELATIVE_PATH }, null, 2));
+        return 0;
+    }
+    reporter.stdout(`${action === 'created' ? 'Created' : 'Updated'} ${candidate.id} in ${TECHNOLOGY_CONFIG_RELATIVE_PATH}`);
+    return 0;
+}
+function runRemove(projectRoot, options, reporter) {
+    const [target] = options.positionals;
+    if (!target) {
+        reporter.stderr(renderCliError('Missing technology id or name', 'mf tech --help'));
+        return 1;
+    }
+    const file = readTechnologyPreferences(projectRoot);
+    if (file.issues.length > 0) {
+        reporter.stderr(renderCliError(`Cannot update invalid ${TECHNOLOGY_CONFIG_RELATIVE_PATH}`, 'mf tech list'));
+        return 1;
+    }
+    const key = normalizeTechnologyKey(target);
+    const matches = file.preferences.filter((preference) => preference.id === target || normalizeTechnologyKey(preference.name) === key);
+    if (matches.length === 0) {
+        reporter.stderr(renderCliError(`No technology preference matched ${target}`, 'mf tech list'));
+        return 1;
+    }
+    if (matches.length > 1) {
+        reporter.stderr(renderCliError(`Multiple technology preferences matched ${target}; remove by id`, 'mf tech list'));
+        return 1;
+    }
+    const removed = matches[0];
+    const preferences = file.preferences.filter((preference) => preference.id !== removed.id);
+    writeTechnologyPreferences(projectRoot, preferences);
+    if (options.json) {
+        reporter.stdout(JSON.stringify({ action: 'removed', preference: removed, path: TECHNOLOGY_CONFIG_RELATIVE_PATH }, null, 2));
+        return 0;
+    }
+    reporter.stdout(`Removed ${removed.id} from ${TECHNOLOGY_CONFIG_RELATIVE_PATH}`);
+    return 0;
+}
+export function runTech(args, reporter, lang = 'en') {
+    if (hasCliOptionToken(args, '--help', ['-h'])) {
+        reporter.stdout(getTechHelp(lang));
+        return 0;
+    }
+    const options = parseTechOptions(args, lang);
+    if (options.error) {
+        printUsageError(reporter, options.error, 'mf tech --help', getTechHelp(lang), lang);
+        return 1;
+    }
+    const projectRoot = resolveMustflowRoot();
+    if (options.action === 'list') {
+        return runList(projectRoot, options, reporter);
+    }
+    if (options.action === 'suggest') {
+        return runSuggest(projectRoot, options, reporter);
+    }
+    if (options.action === 'add') {
+        return runAdd(projectRoot, options, reporter);
+    }
+    return runRemove(projectRoot, options, reporter);
+}

package/dist/cli/i18n/en.js

@@ -41,6 +41,7 @@ export const enMessages = {
     "command.lineEndings.summary": "Inspect and normalize line-ending policy",
     "command.run.summary": "Run a configured oneshot command",
     "command.context.summary": "Print machine-readable agent context",
+    "command.tech.summary": "Manage technology preferences for agents",
     "command.doctor.summary": "Inspect mustflow health and next steps",
     "command.docs.summary": "Track documentation review queue entries",
     "command.handoff.summary": "Validate restricted work-item and handoff records",

package/dist/cli/i18n/es.js

@@ -41,6 +41,7 @@ export const esMessages = {
     "command.lineEndings.summary": "Inspecciona y normaliza la política de finales de línea",
     "command.run.summary": "Ejecuta un comando configurado de una sola ejecución",
     "command.context.summary": "Imprime contexto de agente legible por máquinas",
+    "command.tech.summary": "Gestiona preferencias tecnológicas para agentes",
     "command.doctor.summary": "Inspecciona la salud de mustflow y los siguientes pasos",
     "command.docs.summary": "Rastrea la cola de revisión de documentación",
     "command.handoff.summary": "Valida registros restringidos de trabajo y handoff",

package/dist/cli/i18n/fr.js

@@ -41,6 +41,7 @@ export const frMessages = {
     "command.lineEndings.summary": "Inspecte et normalise la politique de fins de ligne",
     "command.run.summary": "Exécute une commande configurée à exécution unique",
     "command.context.summary": "Imprime le contexte d'agent lisible par machine",
+    "command.tech.summary": "Gère les préférences technologiques pour les agents",
     "command.doctor.summary": "Inspecte l'état de mustflow et les prochaines étapes",
     "command.docs.summary": "Suit la file de révision de documentation",
     "command.handoff.summary": "Valide les enregistrements restreints de travail et de handoff",

package/dist/cli/i18n/hi.js

@@ -41,6 +41,7 @@ export const hiMessages = {
     "command.lineEndings.summary": "लाइन-एंडिंग नीति की जाँच और सामान्यीकरण करें",
     "command.run.summary": "कॉन्फ़िगर की गई एक-बार चलने वाली कमांड चलाएँ",
     "command.context.summary": "मशीन-पठनीय एजेंट संदर्भ प्रिंट करें",
+    "command.tech.summary": "एजेंटों के लिए technology preferences प्रबंधित करें",
     "command.doctor.summary": "mustflow स्वास्थ्य और अगले कदम जाँचें",
     "command.docs.summary": "दस्तावेज़ review queue entries track करें",
     "command.handoff.summary": "Restricted work-item और handoff records validate करें",

package/dist/cli/i18n/ko.js

@@ -41,6 +41,7 @@ export const koMessages = {
     "command.lineEndings.summary": "줄바꿈 정책을 검사하고 정규화합니다",
     "command.run.summary": "설정된 일회성 명령을 실행합니다",
     "command.context.summary": "에이전트 작업 맥락을 출력합니다",
+    "command.tech.summary": "에이전트용 기술 선호를 관리합니다",
     "command.doctor.summary": "mustflow 상태를 점검하고 후속 조치를 안내합니다",
     "command.docs.summary": "문서 검수 대기열 항목을 추적합니다",
     "command.handoff.summary": "제한된 작업 항목과 인수인계 기록을 검증합니다",

package/dist/cli/i18n/zh.js

@@ -41,6 +41,7 @@ export const zhMessages = {
     "command.lineEndings.summary": "检查并规范化换行符策略",
     "command.run.summary": "运行已配置的一次性命令",
     "command.context.summary": "输出机器可读的代理上下文",
+    "command.tech.summary": "管理代理使用的技术偏好",
     "command.doctor.summary": "检查 mustflow 健康状态和后续步骤",
     "command.docs.summary": "跟踪文档审阅队列条目",
     "command.handoff.summary": "验证受限的工作项和交接记录",

package/dist/cli/index.js

@@ -43,6 +43,7 @@ function getTopLevelHelp(lang) {
             'mf workspace status --json',
             'mf workspace verify --changed --plan-only --json',
             'mf context --json',
+            'mf tech suggest --scope frontend',
             'mf map --write',
             'mf search mustflow_check',
             'mf explain authority AGENTS.md',

package/dist/cli/lib/agent-context.js

@@ -9,10 +9,12 @@ import { inspectManifestLock } from './manifest-lock.js';
 import { MUSTFLOW_JSON_MAX_BYTES, readMustflowTextFile, readMustflowTextFileIfExists, } from './mustflow-read.js';
 import { createRunPlan } from './run-plan.js';
 import { readMustflowTomlFile } from './toml.js';
+import { normalizeTechnologyPreferencesTable, TECHNOLOGY_CONFIG_RELATIVE_PATH, } from '../../core/technology-preferences.js';
 const CONTEXT_SCHEMA_VERSION = '1';
 const COMMANDS_RELATIVE_PATH = '.mustflow/config/commands.toml';
 const MUSTFLOW_RELATIVE_PATH = '.mustflow/config/mustflow.toml';
 const PREFERENCES_RELATIVE_PATH = '.mustflow/config/preferences.toml';
+const TECHNOLOGY_RELATIVE_PATH = TECHNOLOGY_CONFIG_RELATIVE_PATH;
 const LATEST_RUN_RELATIVE_PATH = '.mustflow/state/runs/latest.json';
 const CACHE_RELATIVE_PATH = '.mustflow/cache/';
 const STATE_RELATIVE_PATH = '.mustflow/state/';
@@ -148,6 +150,19 @@ function readCommandContractContext(projectRoot) {
         runnable_intents: runnableIntents,
     };
 }
+function readTechnologyPreferencesContext(projectRoot) {
+    const technology = readTomlTableIfExists(projectRoot, TECHNOLOGY_RELATIVE_PATH);
+    const file = normalizeTechnologyPreferencesTable(technology, safeExists(projectRoot, TECHNOLOGY_RELATIVE_PATH));
+    return {
+        path: file.path,
+        exists: file.exists,
+        authority: file.authority,
+        guidance: file.guidance,
+        count: file.preferences.length,
+        preferences: file.preferences,
+        issues: file.issues,
+    };
+}
 function readEffectivePolicyContext(mustflow, preferences) {
     const verification = readNestedTable(mustflow, 'verification');
     const retention = readNestedTable(mustflow, 'retention');
@@ -342,6 +357,7 @@ export function getAgentContext(projectRoot) {
         read_order: readPathContext(projectRoot, readOrder),
         optional_read_order: readPathContext(projectRoot, optionalReadOrder),
         command_contract: readCommandContractContext(projectRoot),
+        technology_preferences: readTechnologyPreferencesContext(projectRoot),
         effective_policy: readEffectivePolicyContext(mustflow, preferences),
         state_policy: readStatePolicyContext(),
         blocked_actions: BLOCKED_ACTIONS,

package/dist/cli/lib/command-registry.js

@@ -101,6 +101,12 @@ export const COMMAND_DEFINITIONS = [
         summaryKey: 'command.context.summary',
         loadRunner: async () => (await import('../commands/context.js')).runContext,
     },
+    {
+        id: 'tech',
+        usage: 'mf tech',
+        summaryKey: 'command.tech.summary',
+        loadRunner: async () => (await import('../commands/tech.js')).runTech,
+    },
     {
         id: 'doctor',
         usage: 'mf doctor',

package/dist/cli/lib/validation/index.js

@@ -16,6 +16,7 @@ import { parseTomlText, readMustflowTomlFile } from '../toml.js';
 import { MUSTFLOW_JSON_MAX_BYTES, readMustflowTextFileResult, } from '../mustflow-read.js';
 import { getContractModelDefinitions, validateCandidateContractModelConfig, } from '../../../core/contract-models.js';
 import { VERSIONING_CONFIG_PATH, detectVersionSourcePaths, readDeclaredVersionSources, releaseVersioningIsEnabled, } from '../../../core/version-sources.js';
+import { normalizeTechnologyPreferencesTable, TECHNOLOGY_CONFIG_RELATIVE_PATH, } from '../../../core/technology-preferences.js';
 import { ALLOWED_APPROVAL_ACTIONS, ALLOWED_APPROVAL_GATES, ALLOWED_BUDGET_LIMIT_ACTIONS, ALLOWED_CAPABILITY_STATES, ALLOWED_COMMIT_MESSAGE_STYLES, ALLOWED_COMPACTION_CATEGORIES, ALLOWED_COMPACTION_LONG_LIMIT_ACTIONS, ALLOWED_COMPACTION_RAW_LIMIT_ACTIONS, ALLOWED_COMPACTION_STATE_STORES, ALLOWED_COMPACTION_STRATEGIES, ALLOWED_CONTEXT_AUTHORITIES, ALLOWED_CONTEXT_DOCUMENT_AUTHORITIES, ALLOWED_CONTEXT_READ_POLICIES, ALLOWED_HANDOFF_MODES, ALLOWED_HARNESS_FRESH_CONTEXT_MODES, ALLOWED_HARNESS_MODES, ALLOWED_HARNESS_PHASES, ALLOWED_ISOLATION_PREFERENCES, ALLOWED_MAP_MODES, ALLOWED_MAP_PRIVACY_LEVELS, ALLOWED_PROJECT_PROFILES, ALLOWED_REPO_MAP_DEGRADED_VALUES, ALLOWED_REPO_MAP_GIT_LS_FILES_STATUSES, ALLOWED_PROMPT_CACHE_STABLE_PREFIX_POLICIES, ALLOWED_PROMPT_CACHE_STRATEGIES, ALLOWED_PROMPT_CACHE_TASK_READ_POLICIES, ALLOWED_REFRESH_CHECKPOINTS, ALLOWED_REFRESH_METHODS, ALLOWED_REFRESH_MODES, ALLOWED_REFRESH_STATE_STORES, ALLOWED_SKILL_RESOURCE_TYPES, ALLOWED_SKILL_ROUTE_CATEGORIES, ALLOWED_SKILL_ROUTE_PROFILES, ALLOWED_SKILL_ROUTE_TYPES, ALLOWED_STALE_TEST_ACTIONS, ALLOWED_TEST_AUTHORING_POLICIES, ALLOWED_TEST_DELETION_REASONS, ALLOWED_TESTING_POLICIES, ALLOWED_TRANSLATION_POLICIES, ALLOWED_VERIFICATION_SELECTION_STRATEGIES, ALLOWED_VERSION_SOURCE_AUTHORITIES, ALLOWED_VERSION_SOURCE_KINDS, CAPABILITY_BOOLEAN_FIELDS, CAPABILITY_STATE_FIELDS, CONTEXT_AUTHORITY_DRIFT_PATTERNS, DESIGN_TOKEN_DEFINITION_PATTERNS, FORBIDDEN_RELEASE_VERSIONING_CONTRACT_FIELDS, FORBIDDEN_TEST_DELETION_REASONS, FORBIDDEN_VERIFICATION_SELECTION_AUTHORITY_FIELDS, LOCAL_ABSOLUTE_PATH_PATTERNS, LOCAL_TASK_STATE_ROOTS, RAW_COMMAND_FENCE_PATTERN, RELEASE_VERSIONING_BOOLEAN_FIELDS, REPO_MAP_DOC_ID, REPO_MAP_GENERATOR, REPO_MAP_LIFECYCLE, REPO_MAP_PRIVACY_MODE, REPO_MAP_RELATIVE_ROOT, REPO_MAP_REMOTE_OR_BRANCH_PATTERNS, REPO_MAP_SOURCE_FINGERPRINT_PATTERN, REPO_MAP_SOURCE_POLICY, REQUIRED_AGENT_LOOP_PHASES, REQUIRED_SKILL_SCRIPT_RUN_POLICY, REQUIRED_SKILL_SECTION_IDS, ROUTER_INDEX_FILES, ROUTER_INDEX_PROCEDURE_SECTION_PATTERN, SECRET_LIKE_CONTEXT_PATTERNS, SKILL_COMMAND_PERMISSION_CLAIM_PATTERNS, SKILL_INDEX_PATH, SKILL_PACK_ID_PATTERN, SKILL_RESOURCE_MANIFEST, SKILL_RESOURCE_ROOTS, SKILL_RESOURCE_TYPE_BY_ROOT, SKILL_ROUTE_CATEGORY_LABELS, SKILL_ROUTES_METADATA_PATH, SKILL_SECTION_MARKER_PATTERN, SUPPORTED_SKILL_SCHEMA_VERSION, TEST_AUTHORING_BOOLEAN_FIELDS, VERIFICATION_SELECTION_BOOLEAN_FIELDS, VOLATILE_REPO_MAP_PATTERNS } from './constants.js';
 import { hasOwn, isPositiveInteger, isSafeRelativePath, pushStrictIssue, pushStrictWarning, validateAllowedStringField, validateBooleanField, validateExactStringArrayField, validateNestedTable, validatePathArrayField, validatePathField, validatePositiveIntegerField, validateRequiredFiles, validateRequiredPathField, validateRequiredStringField, validateStringArrayField, validateStringArrayMembers, validateStringField, validateTable, validateToml, validateWorkspaceRoots } from './primitives.js';
 import { isConfiguredCommandIntent, isDeclaredCommandIntent } from './command-intents.js';
@@ -419,6 +420,15 @@ function validatePreferencesConfig(preferencesToml, issues) {
         validateStringArrayField(productI18n, 'do_not_translate', '[preferences.product_i18n].do_not_translate', issues);
     }
 }
+function validateTechnologyConfig(technologyToml, issues) {
+    if (!technologyToml) {
+        return;
+    }
+    const technology = normalizeTechnologyPreferencesTable(technologyToml, true);
+    for (const issue of technology.issues) {
+        issues.push({ message: `${TECHNOLOGY_CONFIG_RELATIVE_PATH}: ${issue}` });
+    }
+}
 function validateVersioningConfig(versioningToml, issues) {
     if (!versioningToml) {
         return;
@@ -1634,6 +1644,7 @@ function collectCheckIssues(projectRoot, options = {}) {
     const parsed = validateToml(projectRoot, issues);
     validateMustflowConfig(parsed.mustflowToml, issues);
     validatePreferencesConfig(parsed.preferencesToml, issues);
+    validateTechnologyConfig(parsed.technologyToml, issues);
     validateVersioningConfig(parsed.versioningToml, issues);
     validateCommandIntents(parsed.commandsToml, issues);
     validateSkills(projectRoot, issues);

package/dist/cli/lib/validation/primitives.js

@@ -3,6 +3,7 @@ import path from 'node:path';
 import { isRecord } from '../command-contract.js';
 import { readMustflowTomlFile } from '../toml.js';
 import { REQUIRED_FILES, } from './constants.js';
+import { TECHNOLOGY_CONFIG_RELATIVE_PATH } from '../../../core/technology-preferences.js';
 import { VERSIONING_CONFIG_PATH } from '../../../core/version-sources.js';
 export function hasOwn(table, key) {
     return Object.prototype.hasOwnProperty.call(table, key);
@@ -34,6 +35,7 @@ export function validateToml(projectRoot, issues) {
         '.mustflow/config/mustflow.toml',
         '.mustflow/config/commands.toml',
         '.mustflow/config/preferences.toml',
+        TECHNOLOGY_CONFIG_RELATIVE_PATH,
         VERSIONING_CONFIG_PATH,
     ]) {
         const filePath = path.join(projectRoot, relativePath);
@@ -55,6 +57,9 @@ export function validateToml(projectRoot, issues) {
             if (relativePath.endsWith('preferences.toml')) {
                 parsedFiles.preferencesToml = parsed;
             }
+            if (relativePath.endsWith('technology.toml')) {
+                parsedFiles.technologyToml = parsed;
+            }
             if (relativePath.endsWith('versioning.toml')) {
                 parsedFiles.versioningToml = parsed;
             }