mustflow 2.23.0 → 2.25.0

package/README.md

@@ -18,7 +18,7 @@ The core concept is straightforward: place `AGENTS.md` at the project root and k
 
 - Use mustflow in your repository: start with [Quick start](#quick-start), then review the [no-guessing workflow](#no-guessing-workflow) and [`examples/minimal-js/`](examples/minimal-js/).
 - Contribute to mustflow: read [CONTRIBUTING.md](CONTRIBUTING.md), then run only configured command intents from [`.mustflow/config/commands.toml`](.mustflow/config/commands.toml).
-- Build an AI coding tool or agent harness: use `AGENTS.md` and `mf context --json` for repository context, then consume JSON output and schemas from `mf classify`, `mf verify`, `mf run`, `mf dashboard`, and [`schemas/`](schemas/).
+- Build an AI coding tool or agent harness: use `AGENTS.md` and `mf context --json` for repository context, then consume JSON output and schemas from `mf api`, `mf classify`, `mf verify`, `mf run`, `mf dashboard`, and [`schemas/`](schemas/).
 
 ## No-guessing workflow
 
@@ -248,6 +248,12 @@ mf run mustflow_update_apply
 | `mf adapters status` | Inspect existing host-specific instruction and adapter files without generating adapter files or granting command authority. |
 | `mf classify --changed` | Classify changed paths, public surfaces, and validation reasons. Add `--write <path>` to save the classification report. |
 | `mf contract-lint` | Inspect `.mustflow/config/commands.toml` for command-contract errors and warnings without running commands. Add `--suggest` to print non-runnable candidate snippets from existing command files. |
+| `mf onboard commands` | Suggest review-only command-intent snippets from package.json, Makefile, or justfile without writing files or granting command authority. |
+| `mf next` | Inspect install state, changed files, verification coverage, and command-contract gaps, then print the next safe mustflow action without running commands. |
+| `mf evidence` | Summarize changed-file verification requirements, latest evidence, receipts, remaining risks, and gaps without running commands. |
+| `mf workspace status` | Inspect configured workspace roots and nested repository contract readiness without granting parent-to-child command authority. |
+| `mf workspace command-catalog` | Aggregate per-repository command intent availability with safe `mf run` entrypoints and no raw command strings. |
+| `mf workspace verify --changed --plan-only` | Aggregate per-repository changed-file verification plans without running commands or granting parent-to-child command authority. |
 | `mf doctor` | Inspect the current mustflow root without writing files. |
 | `mf api workspace-summary --json` | Print a stable, read-only JSON summary for coding agents and external harnesses. |
 | `mf api command-catalog --json` | Print command intent availability and safe `mf run` entrypoints without exposing raw command strings. |
@@ -256,6 +262,7 @@ mf run mustflow_update_apply
 | `mf api diff-risk --changed --json` | Print a compact changed-file risk, verification summary, and read-only residual correction signals. |
 | `mf api health --json` | Print a compact workspace health report for quick agent gating. |
 | `mf api locks --json` | Print active `mf run` locks for multi-session coordination. |
+| `mf api serve --stdio` | Serve the same read-only API reports as newline-delimited JSON responses over stdin/stdout. |
 | `mf docs review list` | Show documents still waiting for prose review after agent edits. |
 | `mf docs review add <path>` | Add or refresh a document review queue entry. |
 | `mf docs review comment <path>` | Add multiline review guidance to an existing queue entry. |
@@ -287,7 +294,7 @@ mf run mustflow_update_apply
 | `mf explain skills` | Explain the strict skill index/body alignment summary used by `mf doctor --strict`. |
 | `mf explain surface [path]` | Explain how a path maps to public-surface and validation categories. |
 
-Automation and agents should use `--json` output instead of parsing human-facing text. Published JSON Schemas for stable outputs live in `schemas/`.
+Automation and agents should use `--json` output or `mf api serve --stdio` JSONL responses instead of parsing human-facing text. Published JSON Schemas for stable outputs live in `schemas/`.
 
 ## Command execution policy
 
@@ -366,6 +373,9 @@ These are ideas not yet officially supported:
 ## Development
 
 Development commands in this repository use Bun. Users do not need Bun to run `mf` in their own projects.
+The mustflow source repository dogfoods the installed workflow files at the repository root: agents
+should read `AGENTS.md`, `.mustflow/docs/agent-workflow.md`, and `.mustflow/config/commands.toml`
+before changing code or running verification.
 
 ```sh
 bun install

package/dist/cli/commands/adapters.js

@@ -1,7 +1,11 @@
 import { inspectAdapterCompatibility } from '../../core/adapter-compatibility.js';
 import { printUsageError, renderHelp } from '../lib/cli-output.js';
 import { t } from '../lib/i18n.js';
+import { formatCliOptionParseError, hasCliOptionToken, hasParsedCliOption, parseCliOptions, } from '../lib/option-parser.js';
 import { resolveMustflowRoot } from '../lib/project-root.js';
+const ADAPTERS_STATUS_OPTIONS = [
+    { name: '--json', kind: 'boolean' },
+];
 export function getAdaptersHelp(lang = 'en') {
     return renderHelp({
         usage: 'mf adapters status [options]',
@@ -19,9 +23,8 @@ export function getAdaptersHelp(lang = 'en') {
 }
 function parseAdaptersArgs(args, lang) {
     const [action, ...rest] = args;
-    const json = rest.includes('--json');
-    const supported = new Set(['--json']);
-    const unsupported = rest.find((arg) => arg.startsWith('-') && !supported.has(arg));
+    const parsed = parseCliOptions(rest, ADAPTERS_STATUS_OPTIONS, { allowPositionals: true });
+    const json = hasParsedCliOption(parsed, '--json');
     if (!action) {
         return {
             action: 'status',
@@ -36,12 +39,11 @@ function parseAdaptersArgs(args, lang) {
             error: t(lang, 'adapters.error.unknownAction', { action }),
         };
     }
-    if (unsupported) {
-        return { action, json, error: t(lang, 'cli.error.unknownOption', { option: unsupported }) };
+    if (parsed.error) {
+        return { action, json, error: formatCliOptionParseError(parsed.error, lang) };
     }
-    if (rest.some((arg) => !arg.startsWith('-'))) {
-        const unexpected = rest.find((arg) => !arg.startsWith('-'));
-        return { action, json, error: t(lang, 'cli.error.unexpectedArgument', { argument: unexpected }) };
+    if (parsed.positionals.length > 0) {
+        return { action, json, error: t(lang, 'cli.error.unexpectedArgument', { argument: parsed.positionals[0] ?? '' }) };
     }
     return { action, json };
 }
@@ -71,7 +73,7 @@ function renderAdapterReport(report, lang) {
     return lines.join('\n');
 }
 export function runAdapters(args, reporter, lang = 'en') {
-    if (args.includes('--help') || args.includes('-h')) {
+    if (hasCliOptionToken(args, '--help', ['-h'])) {
         reporter.stdout(getAdaptersHelp(lang));
         return 0;
     }

package/dist/cli/commands/api.js

@@ -1,11 +1,13 @@
 import { existsSync } from 'node:fs';
 import path from 'node:path';
+import { createInterface } from 'node:readline';
 import { createClassifyOutput } from './classify.js';
 import { listActiveRunLocks } from '../../core/active-run-locks.js';
 import { createChangeVerificationReport, } from '../../core/change-verification.js';
 import { readUtf8FileInsideWithoutSymlinks } from '../../core/safe-filesystem.js';
 import { createVerificationPlanId } from '../../core/verification-plan-id.js';
 import { printUsageError, renderHelp } from '../lib/cli-output.js';
+import { formatCliOptionParseError, hasCliOptionToken, hasParsedCliOption, parseCliOptions, } from '../lib/option-parser.js';
 import { getAgentContext } from '../lib/agent-context.js';
 import { isRecord, readCommandContract, readPositiveInteger, readString, readStringArray, } from '../lib/command-contract.js';
 import { readGitChangedFiles } from '../lib/git-changes.js';
@@ -20,58 +22,97 @@ const API_LATEST_EVIDENCE_SCHEMA_VERSION = '1';
 const API_DIFF_RISK_SCHEMA_VERSION = '1';
 const API_HEALTH_SCHEMA_VERSION = '1';
 const API_LOCKS_SCHEMA_VERSION = '1';
+const API_SERVE_SCHEMA_VERSION = '1';
 const COMMANDS_RELATIVE_PATH = '.mustflow/config/commands.toml';
 const LATEST_RUN_RELATIVE_PATH = '.mustflow/state/runs/latest.json';
 const LOCKS_RELATIVE_PATH = '.mustflow/state/locks';
 const MUSTFLOW_JSON_MAX_BYTES = 1024 * 1024;
+const API_JSON_ONLY_OPTIONS = [
+    { name: '--json', kind: 'boolean' },
+    { name: '--help', kind: 'boolean', aliases: ['-h'] },
+];
+const API_CHANGED_JSON_OPTIONS = [
+    { name: '--changed', kind: 'boolean' },
+    { name: '--json', kind: 'boolean' },
+    { name: '--help', kind: 'boolean', aliases: ['-h'] },
+];
+const API_SERVE_OPTIONS = [
+    { name: '--stdio', kind: 'boolean' },
+    { name: '--help', kind: 'boolean', aliases: ['-h'] },
+];
+const API_REPORT_ACTIONS = [
+    {
+        action: 'workspace-summary',
+        requiresChanged: false,
+        helpKey: 'api.help.action.workspaceSummary',
+        example: 'mf api workspace-summary --json',
+    },
+    {
+        action: 'command-catalog',
+        requiresChanged: false,
+        helpKey: 'api.help.action.commandCatalog',
+        example: 'mf api command-catalog --json',
+    },
+    {
+        action: 'verification-plan',
+        requiresChanged: true,
+        helpKey: 'api.help.action.verificationPlan',
+        example: 'mf api verification-plan --changed --json',
+    },
+    {
+        action: 'latest-evidence',
+        requiresChanged: false,
+        helpKey: 'api.help.action.latestEvidence',
+        example: 'mf api latest-evidence --json',
+    },
+    {
+        action: 'diff-risk',
+        requiresChanged: true,
+        helpKey: 'api.help.action.diffRisk',
+        example: 'mf api diff-risk --changed --json',
+    },
+    {
+        action: 'health',
+        requiresChanged: false,
+        helpKey: 'api.help.action.health',
+        example: 'mf api health --json',
+    },
+    {
+        action: 'locks',
+        requiresChanged: false,
+        helpKey: 'api.help.action.locks',
+        example: 'mf api locks --json',
+    },
+];
+const API_REPORT_ACTION_NAMES = new Set(API_REPORT_ACTIONS.map((spec) => spec.action));
+function isApiReportAction(value) {
+    return API_REPORT_ACTION_NAMES.has(value);
+}
+function apiReportActionSpec(action) {
+    const spec = API_REPORT_ACTIONS.find((candidate) => candidate.action === action);
+    if (!spec) {
+        throw new Error(`Unknown API report action: ${action}`);
+    }
+    return spec;
+}
 export function getApiHelp(lang = 'en') {
     return renderHelp({
         usage: 'mf api <action> [options]',
         summary: t(lang, 'api.help.summary'),
         commands: [
-            {
-                label: 'workspace-summary',
-                description: t(lang, 'api.help.action.workspaceSummary'),
-            },
-            {
-                label: 'command-catalog',
-                description: t(lang, 'api.help.action.commandCatalog'),
-            },
-            {
-                label: 'verification-plan',
-                description: t(lang, 'api.help.action.verificationPlan'),
-            },
-            {
-                label: 'latest-evidence',
-                description: t(lang, 'api.help.action.latestEvidence'),
-            },
-            {
-                label: 'diff-risk',
-                description: t(lang, 'api.help.action.diffRisk'),
-            },
-            {
-                label: 'health',
-                description: t(lang, 'api.help.action.health'),
-            },
-            {
-                label: 'locks',
-                description: t(lang, 'api.help.action.locks'),
-            },
+            ...API_REPORT_ACTIONS.map((spec) => ({
+                label: spec.action,
+                description: t(lang, spec.helpKey),
+            })),
+            { label: 'serve', description: t(lang, 'api.help.action.serve') },
         ],
         options: [
             { label: '--changed', description: t(lang, 'classify.help.option.changed') },
             { label: '--json', description: t(lang, 'cli.option.json') },
+            { label: '--stdio', description: t(lang, 'api.help.option.stdio') },
             { label: '-h, --help', description: t(lang, 'cli.option.help') },
         ],
-        examples: [
-            'mf api workspace-summary --json',
-            'mf api command-catalog --json',
-            'mf api verification-plan --changed --json',
-            'mf api latest-evidence --json',
-            'mf api diff-risk --changed --json',
-            'mf api health --json',
-            'mf api locks --json',
-        ],
+        examples: [...API_REPORT_ACTIONS.map((spec) => spec.example), 'mf api serve --stdio'],
         exitCodes: [
             { label: '0', description: t(lang, 'api.help.exit.ok') },
             { label: '1', description: t(lang, 'cli.common.invalidInput') },
@@ -983,95 +1024,217 @@ function createLocksOutput() {
         };
     }
 }
+function createApiReport(action) {
+    switch (action) {
+        case 'workspace-summary':
+            return createWorkspaceSummaryOutput();
+        case 'command-catalog':
+            return createCommandCatalogOutput();
+        case 'verification-plan':
+            return createVerificationPlanOutput();
+        case 'latest-evidence':
+            return createLatestEvidenceOutput();
+        case 'diff-risk':
+            return createDiffRiskOutput();
+        case 'health':
+            return createHealthOutput();
+        case 'locks':
+            return createLocksOutput();
+    }
+}
+function writeApiReport(action, reporter) {
+    reporter.stdout(JSON.stringify(createApiReport(action), null, 2));
+}
+function createApiServePolicy() {
+    return {
+        mode: 'read_only',
+        executes_commands: false,
+        direct_commands_allowed: false,
+        raw_output_included: false,
+        hidden_reasoning_included: false,
+    };
+}
+function createApiServeError(id, code, message) {
+    return {
+        schema_version: API_SERVE_SCHEMA_VERSION,
+        command: 'api serve',
+        transport: 'stdio',
+        id,
+        ok: false,
+        policy: createApiServePolicy(),
+        error: {
+            code,
+            message,
+        },
+    };
+}
+function createApiServeSuccess(id, result) {
+    return {
+        schema_version: API_SERVE_SCHEMA_VERSION,
+        command: 'api serve',
+        transport: 'stdio',
+        id,
+        ok: true,
+        policy: createApiServePolicy(),
+        result,
+    };
+}
+function readApiServeId(request) {
+    if (!isRecord(request) || !Object.hasOwn(request, 'id')) {
+        return null;
+    }
+    const value = request.id;
+    if (typeof value === 'string' || typeof value === 'number' || value === null) {
+        return value;
+    }
+    return null;
+}
+function parseApiServeRequestLine(line) {
+    let parsed;
+    try {
+        parsed = JSON.parse(line);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            request: null,
+            error: createApiServeError(null, 'invalid_json', `Invalid JSON request: ${message}`),
+        };
+    }
+    const id = readApiServeId(parsed);
+    if (!isRecord(parsed)) {
+        return {
+            request: null,
+            error: createApiServeError(id, 'invalid_request', 'Request must be a JSON object.'),
+        };
+    }
+    return {
+        request: {
+            id,
+            action: parsed.action,
+            changed: parsed.changed,
+        },
+        error: null,
+    };
+}
+function createApiServeResponse(request) {
+    const id = typeof request.id === 'string' || typeof request.id === 'number' || request.id === null ? request.id : null;
+    if (typeof request.action !== 'string') {
+        return createApiServeError(id, 'invalid_request', 'Request field "action" must be a string.');
+    }
+    if (!isApiReportAction(request.action)) {
+        return createApiServeError(id, 'unknown_action', `Unknown api action: ${request.action}`);
+    }
+    const spec = apiReportActionSpec(request.action);
+    if (spec.requiresChanged && request.changed !== true) {
+        return createApiServeError(id, 'action_requires_changed', `${request.action} requires changed: true.`);
+    }
+    if (!spec.requiresChanged && request.changed === true) {
+        return createApiServeError(id, 'action_does_not_accept_changed', `${request.action} does not accept changed: true.`);
+    }
+    try {
+        return createApiServeSuccess(id, createApiReport(request.action));
+    }
+    catch (error) {
+        return createApiServeError(id, 'report_unavailable', error instanceof Error ? error.message : String(error));
+    }
+}
+function writeApiServeResponse(response, reporter) {
+    const line = `${JSON.stringify(response)}\n`;
+    if (reporter.writeStdout) {
+        reporter.writeStdout(line);
+        return;
+    }
+    reporter.stdout(line.trimEnd());
+}
+async function runApiServe(args, reporter, lang) {
+    const parsed = parseCliOptions(args, API_SERVE_OPTIONS);
+    if (hasParsedCliOption(parsed, '--help')) {
+        reporter.stdout(getApiHelp(lang));
+        return 0;
+    }
+    if (parsed.error) {
+        printUsageError(reporter, formatCliOptionParseError(parsed.error, lang), 'mf api --help', getApiHelp(lang), lang);
+        return 1;
+    }
+    if (!hasParsedCliOption(parsed, '--stdio')) {
+        printUsageError(reporter, t(lang, 'api.error.serveRequiresStdio'), 'mf api --help', getApiHelp(lang), lang);
+        return 1;
+    }
+    const input = createInterface({
+        input: process.stdin,
+        crlfDelay: Infinity,
+    });
+    for await (const rawLine of input) {
+        const line = rawLine.trim();
+        if (line.length === 0) {
+            continue;
+        }
+        const parsed = parseApiServeRequestLine(line);
+        if (parsed.error) {
+            writeApiServeResponse(parsed.error, reporter);
+            continue;
+        }
+        if (!parsed.request) {
+            writeApiServeResponse(createApiServeError(null, 'invalid_request', 'Request must be a JSON object.'), reporter);
+            continue;
+        }
+        writeApiServeResponse(createApiServeResponse(parsed.request), reporter);
+    }
+    return 0;
+}
 function validateJsonOnlyAction(action, args, reporter, lang) {
-    if (args.includes('--help') || args.includes('-h')) {
+    const parsed = parseCliOptions(args, API_JSON_ONLY_OPTIONS);
+    if (hasParsedCliOption(parsed, '--help')) {
         reporter.stdout(getApiHelp(lang));
         return false;
     }
-    const supported = new Set(['--json']);
-    const unsupported = args.filter((arg) => !supported.has(arg));
-    if (unsupported.length > 0) {
-        printUsageError(reporter, t(lang, 'cli.error.unknownOption', { option: unsupported[0] }), 'mf api --help', getApiHelp(lang), lang);
+    if (parsed.error) {
+        printUsageError(reporter, formatCliOptionParseError(parsed.error, lang), 'mf api --help', getApiHelp(lang), lang);
         return false;
     }
-    if (!args.includes('--json')) {
+    if (!hasParsedCliOption(parsed, '--json')) {
         printUsageError(reporter, t(lang, 'api.error.actionRequiresJson', { action }), 'mf api --help', getApiHelp(lang), lang);
         return false;
     }
     return true;
 }
-function runWorkspaceSummary(args, reporter, lang) {
-    if (!validateJsonOnlyAction('workspace-summary', args, reporter, lang)) {
-        return args.includes('--help') || args.includes('-h') ? 0 : 1;
-    }
-    reporter.stdout(JSON.stringify(createWorkspaceSummaryOutput(), null, 2));
-    return 0;
-}
-function runCommandCatalog(args, reporter, lang) {
-    if (!validateJsonOnlyAction('command-catalog', args, reporter, lang)) {
-        return args.includes('--help') || args.includes('-h') ? 0 : 1;
-    }
-    reporter.stdout(JSON.stringify(createCommandCatalogOutput(), null, 2));
-    return 0;
-}
 function validateChangedJsonAction(action, args, reporter, lang) {
-    if (args.includes('--help') || args.includes('-h')) {
+    const parsed = parseCliOptions(args, API_CHANGED_JSON_OPTIONS);
+    if (hasParsedCliOption(parsed, '--help')) {
         reporter.stdout(getApiHelp(lang));
         return false;
     }
-    const supported = new Set(['--changed', '--json']);
-    const unsupported = args.filter((arg) => !supported.has(arg));
-    if (unsupported.length > 0) {
-        printUsageError(reporter, t(lang, 'cli.error.unknownOption', { option: unsupported[0] }), 'mf api --help', getApiHelp(lang), lang);
+    if (parsed.error) {
+        printUsageError(reporter, formatCliOptionParseError(parsed.error, lang), 'mf api --help', getApiHelp(lang), lang);
         return false;
     }
-    if (!args.includes('--json')) {
+    if (!hasParsedCliOption(parsed, '--json')) {
         printUsageError(reporter, t(lang, 'api.error.actionRequiresJson', { action }), 'mf api --help', getApiHelp(lang), lang);
         return false;
     }
-    if (!args.includes('--changed')) {
+    if (!hasParsedCliOption(parsed, '--changed')) {
         printUsageError(reporter, t(lang, 'api.error.actionRequiresChanged', { action }), 'mf api --help', getApiHelp(lang), lang);
         return false;
     }
     return true;
 }
-function runVerificationPlan(args, reporter, lang) {
-    if (!validateChangedJsonAction('verification-plan', args, reporter, lang)) {
-        return args.includes('--help') || args.includes('-h') ? 0 : 1;
-    }
-    reporter.stdout(JSON.stringify(createVerificationPlanOutput(), null, 2));
-    return 0;
-}
-function runLatestEvidence(args, reporter, lang) {
-    if (!validateJsonOnlyAction('latest-evidence', args, reporter, lang)) {
-        return args.includes('--help') || args.includes('-h') ? 0 : 1;
+function runJsonOnlyApiReport(action, args, reporter, lang) {
+    if (!validateJsonOnlyAction(action, args, reporter, lang)) {
+        return hasCliOptionToken(args, '--help', ['-h']) ? 0 : 1;
     }
-    reporter.stdout(JSON.stringify(createLatestEvidenceOutput(), null, 2));
+    writeApiReport(action, reporter);
     return 0;
 }
-function runDiffRisk(args, reporter, lang) {
-    if (!validateChangedJsonAction('diff-risk', args, reporter, lang)) {
-        return args.includes('--help') || args.includes('-h') ? 0 : 1;
+function runChangedApiReport(action, args, reporter, lang) {
+    if (!validateChangedJsonAction(action, args, reporter, lang)) {
+        return hasCliOptionToken(args, '--help', ['-h']) ? 0 : 1;
     }
-    reporter.stdout(JSON.stringify(createDiffRiskOutput(), null, 2));
-    return 0;
-}
-function runHealth(args, reporter, lang) {
-    if (!validateJsonOnlyAction('health', args, reporter, lang)) {
-        return args.includes('--help') || args.includes('-h') ? 0 : 1;
-    }
-    reporter.stdout(JSON.stringify(createHealthOutput(), null, 2));
-    return 0;
-}
-function runLocks(args, reporter, lang) {
-    if (!validateJsonOnlyAction('locks', args, reporter, lang)) {
-        return args.includes('--help') || args.includes('-h') ? 0 : 1;
-    }
-    reporter.stdout(JSON.stringify(createLocksOutput(), null, 2));
+    writeApiReport(action, reporter);
     return 0;
 }
 export function runApi(args, reporter, lang = 'en') {
-    if (args.includes('--help') || args.includes('-h')) {
+    if (hasCliOptionToken(args, '--help', ['-h'])) {
         reporter.stdout(getApiHelp(lang));
         return 0;
     }
@@ -1084,26 +1247,13 @@ export function runApi(args, reporter, lang = 'en') {
         printUsageError(reporter, t(lang, 'cli.error.unknownOption', { option: action }), 'mf api --help', getApiHelp(lang), lang);
         return 1;
     }
-    if (action === 'workspace-summary') {
-        return runWorkspaceSummary(rest, reporter, lang);
-    }
-    if (action === 'command-catalog') {
-        return runCommandCatalog(rest, reporter, lang);
-    }
-    if (action === 'verification-plan') {
-        return runVerificationPlan(rest, reporter, lang);
-    }
-    if (action === 'latest-evidence') {
-        return runLatestEvidence(rest, reporter, lang);
-    }
-    if (action === 'diff-risk') {
-        return runDiffRisk(rest, reporter, lang);
-    }
-    if (action === 'health') {
-        return runHealth(rest, reporter, lang);
+    if (action === 'serve') {
+        return runApiServe(rest, reporter, lang);
     }
-    if (action === 'locks') {
-        return runLocks(rest, reporter, lang);
+    if (isApiReportAction(action)) {
+        return apiReportActionSpec(action).requiresChanged
+            ? runChangedApiReport(action, rest, reporter, lang)
+            : runJsonOnlyApiReport(action, rest, reporter, lang);
     }
     printUsageError(reporter, t(lang, 'api.error.unknownAction', { action }), 'mf api --help', getApiHelp(lang), lang);
     return 1;

package/dist/cli/commands/check.js

@@ -1,7 +1,12 @@
 import { printUsageError, renderHelp } from '../lib/cli-output.js';
 import { t } from '../lib/i18n.js';
+import { formatCliOptionParseError, hasCliOptionToken, hasParsedCliOption, parseCliOptions, } from '../lib/option-parser.js';
 import { resolveMustflowRoot } from '../lib/project-root.js';
 import { checkMustflowProjectReport } from '../lib/validation.js';
+const CHECK_OPTIONS = [
+    { name: '--json', kind: 'boolean' },
+    { name: '--strict', kind: 'boolean' },
+];
 export function getCheckHelp(lang = 'en') {
     return renderHelp({
         usage: 'mf check [options]',
@@ -28,22 +33,21 @@ export function getCheckHelp(lang = 'en') {
     }, lang);
 }
 export function runCheck(args, reporter, lang = 'en') {
-    if (args.includes('--help') || args.includes('-h')) {
+    if (hasCliOptionToken(args, '--help', ['-h'])) {
         reporter.stdout(getCheckHelp(lang));
         return 0;
     }
-    const supported = new Set(['--json', '--strict']);
-    const unsupported = args.filter((arg) => !supported.has(arg));
-    if (unsupported.length > 0) {
-        printUsageError(reporter, t(lang, 'cli.error.unknownOption', { option: unsupported[0] }), 'mf check --help', getCheckHelp(lang), lang);
+    const options = parseCliOptions(args, CHECK_OPTIONS);
+    if (options.error) {
+        printUsageError(reporter, formatCliOptionParseError(options.error, lang), 'mf check --help', getCheckHelp(lang), lang);
         return 1;
     }
-    const strict = args.includes('--strict');
+    const strict = hasParsedCliOption(options, '--strict');
     const report = checkMustflowProjectReport(resolveMustflowRoot(), { strict });
     const issues = report.issues;
     const warnings = report.warnings;
     const ok = issues.length === 0;
-    if (args.includes('--json')) {
+    if (hasParsedCliOption(options, '--json')) {
         reporter.stdout(JSON.stringify({
             ok,
             strict,