mustflow 1.15.97

package/dist/cli/commands/docs.js

@@ -0,0 +1,382 @@
+import { unlinkSync } from 'node:fs';
+import path from 'node:path';
+import { printUsageError, renderCliError, renderHelp } from '../lib/cli-output.js';
+import { DOC_REVIEW_LEDGER_RELATIVE_PATH, DOC_REVIEW_STATUSES, REVIEWER_KINDS, addDocReviewEntry, commentDocReviewEntry, isReviewerKind, listDocReviewEntries, markDocReviewEntry, } from '../lib/doc-review-ledger.js';
+import { ensureInside, readUtf8FileInsideWithoutSymlinks } from '../lib/filesystem.js';
+import { t } from '../lib/i18n.js';
+import { resolveMustflowRoot } from '../lib/project-root.js';
+const LIST_FLAGS = new Set(['--json', '--all']);
+const LIST_VALUE_OPTIONS = new Set(['--status']);
+const ADD_VALUE_OPTIONS = new Set(['--reason', '--origin', '--actor-kind', '--actor-id', '--comment', '--comment-file']);
+const COMMENT_VALUE_OPTIONS = new Set(['--comment', '--comment-file', '--actor-kind', '--actor-id']);
+const REVIEW_VALUE_OPTIONS = new Set([
+    '--reviewer-kind',
+    '--reviewer-id',
+    '--reviewer-label',
+    '--reviewer-provider',
+    '--reviewer-model',
+    '--command-intent',
+    '--summary',
+]);
+export function getDocsHelp(lang = 'en') {
+    return renderHelp({
+        usage: 'mf docs review <list|add|comment|approve|needs-human|ignore> [options]',
+        summary: t(lang, 'docs.help.summary'),
+        options: [
+            { label: '--json', description: t(lang, 'cli.option.json') },
+            { label: '--all', description: t(lang, 'docs.help.option.all') },
+            { label: '--status <status>', description: t(lang, 'docs.help.option.status') },
+            { label: '--reason <text>', description: t(lang, 'docs.help.option.reason') },
+            { label: '--origin <value>', description: t(lang, 'docs.help.option.origin') },
+            { label: '--actor-kind <kind>', description: t(lang, 'docs.help.option.actorKind') },
+            { label: '--actor-id <id>', description: t(lang, 'docs.help.option.actorId') },
+            { label: '--comment <text>', description: t(lang, 'docs.help.option.comment') },
+            { label: '--comment-file <path>', description: t(lang, 'docs.help.option.commentFile') },
+            { label: '--reviewer-kind <kind>', description: t(lang, 'docs.help.option.reviewerKind') },
+            { label: '--reviewer-id <id>', description: t(lang, 'docs.help.option.reviewerId') },
+            { label: '--summary <text>', description: t(lang, 'docs.help.option.summary') },
+            { label: '-h, --help', description: t(lang, 'cli.option.help') },
+        ],
+        examples: [
+            'mf docs review list',
+            'mf docs review add docs/guide.md --reason llm_modified --actor-kind llm --actor-id codex',
+            'mf docs review comment docs/guide.md --comment-file review-note.md --actor-kind human --actor-id cherr',
+            'mf docs review approve docs/guide.md --reviewer-kind llm --reviewer-id opencode --summary "Rewritten for natural tone."',
+        ],
+        exitCodes: [
+            { label: '0', description: t(lang, 'docs.help.exit.ok') },
+            { label: '1', description: t(lang, 'docs.help.exit.fail') },
+        ],
+    }, lang);
+}
+function parseOptions(args, valueOptions, flags) {
+    const values = new Map();
+    const parsedFlags = new Set();
+    const positionals = [];
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (flags.has(arg)) {
+            parsedFlags.add(arg);
+            continue;
+        }
+        const equalsIndex = arg.indexOf('=');
+        const optionName = equalsIndex > -1 ? arg.slice(0, equalsIndex) : arg;
+        if (valueOptions.has(optionName)) {
+            const inlineValue = equalsIndex > -1 ? arg.slice(equalsIndex + 1) : undefined;
+            const nextValue = inlineValue ?? args[index + 1];
+            if (!nextValue || (!inlineValue && nextValue.startsWith('-'))) {
+                return { values, flags: parsedFlags, positionals, error: { option: optionName, missingValue: true } };
+            }
+            values.set(optionName, nextValue);
+            if (inlineValue === undefined) {
+                index += 1;
+            }
+            continue;
+        }
+        if (arg.startsWith('-')) {
+            return { values, flags: parsedFlags, positionals, error: { option: arg } };
+        }
+        positionals.push(arg);
+    }
+    return { values, flags: parsedFlags, positionals };
+}
+function parseStatus(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    return DOC_REVIEW_STATUSES.includes(value) ? value : undefined;
+}
+function parseReviewerKind(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    return isReviewerKind(value) ? value : undefined;
+}
+function readCommentFile(projectRoot, commentFile) {
+    const commentFilePath = path.resolve(projectRoot, commentFile);
+    ensureInside(projectRoot, commentFilePath);
+    return {
+        comment: readUtf8FileInsideWithoutSymlinks(projectRoot, commentFilePath).trimEnd(),
+        absolutePath: commentFilePath,
+    };
+}
+function readReviewComment(projectRoot, parsed, lang) {
+    const inlineComment = parsed.values.get('--comment');
+    const commentFile = parsed.values.get('--comment-file');
+    if (inlineComment && commentFile) {
+        return { error: t(lang, 'docs.error.commentSourceConflict') };
+    }
+    if (!inlineComment && !commentFile) {
+        return {};
+    }
+    let comment;
+    let importedCommentFilePath;
+    try {
+        if (commentFile) {
+            const imported = readCommentFile(projectRoot, commentFile);
+            comment = imported.comment;
+            importedCommentFilePath = imported.absolutePath;
+        }
+        else {
+            comment = inlineComment;
+        }
+    }
+    catch (error) {
+        return { error: error instanceof Error ? error.message : String(error) };
+    }
+    if (!comment || comment.trim().length === 0) {
+        return { error: t(lang, 'docs.error.emptyComment') };
+    }
+    return { comment, importedCommentFilePath };
+}
+function ensureCommentFileIsNotDocument(projectRoot, documentPath, commentFilePath, lang) {
+    if (!commentFilePath) {
+        return undefined;
+    }
+    const documentAbsolutePath = path.resolve(projectRoot, documentPath);
+    ensureInside(projectRoot, documentAbsolutePath);
+    const normalizedDocumentPath = path.normalize(documentAbsolutePath);
+    const normalizedCommentFilePath = path.normalize(commentFilePath);
+    const isSamePath = process.platform === 'win32'
+        ? normalizedDocumentPath.toLowerCase() === normalizedCommentFilePath.toLowerCase()
+        : normalizedDocumentPath === normalizedCommentFilePath;
+    return isSamePath ? t(lang, 'docs.error.commentFileIsDocument') : undefined;
+}
+function removeImportedCommentFile(importedCommentFilePath) {
+    if (importedCommentFilePath) {
+        unlinkSync(importedCommentFilePath);
+    }
+}
+function renderEntries(entries, lang) {
+    const lines = [t(lang, 'docs.review.title'), `${t(lang, 'label.documents')}: ${entries.length}`];
+    if (entries.length === 0) {
+        lines.push(t(lang, 'docs.review.empty'));
+        return lines.join('\n');
+    }
+    for (const entry of entries) {
+        const blocking = entry.release_blocking ? ' release-blocking' : '';
+        lines.push(`- ${entry.path} [${entry.status} ${entry.review_priority}${blocking}] ${entry.reason}`);
+        if (entry.review_comment) {
+            const firstLine = entry.review_comment.split(/\r?\n/).find((line) => line.trim().length > 0);
+            lines.push(`  ${t(lang, 'label.comment')}: ${firstLine ?? entry.review_comment}`);
+        }
+    }
+    return lines.join('\n');
+}
+function renderEntryAction(action, path, lang) {
+    return `${t(lang, 'docs.review.wrote')}: ${DOC_REVIEW_LEDGER_RELATIVE_PATH}\n${action}: ${path}`;
+}
+function getMarkedAction(status, lang) {
+    if (status === 'approved') {
+        return t(lang, 'docs.review.marked.approved');
+    }
+    if (status === 'needs_human') {
+        return t(lang, 'docs.review.marked.needs_human');
+    }
+    return t(lang, 'docs.review.marked.ignored');
+}
+function usageError(reporter, message, lang) {
+    printUsageError(reporter, message, 'mf docs --help', getDocsHelp(lang), lang);
+    return 1;
+}
+function runReviewList(args, reporter, lang) {
+    const parsed = parseOptions(args, LIST_VALUE_OPTIONS, LIST_FLAGS);
+    if (parsed.error) {
+        const message = parsed.error.missingValue
+            ? t(lang, 'cli.error.missingValue', { option: parsed.error.option })
+            : t(lang, 'cli.error.unknownOption', { option: parsed.error.option });
+        return usageError(reporter, message, lang);
+    }
+    if (parsed.positionals.length > 0) {
+        return usageError(reporter, t(lang, 'cli.error.unexpectedArgument', { argument: parsed.positionals[0] }), lang);
+    }
+    const status = parseStatus(parsed.values.get('--status'));
+    if (parsed.values.has('--status') && !status) {
+        return usageError(reporter, t(lang, 'docs.error.invalidStatus', { statuses: DOC_REVIEW_STATUSES.join(', ') }), lang);
+    }
+    const entries = listDocReviewEntries(resolveMustflowRoot(), {
+        includeAll: parsed.flags.has('--all'),
+        status,
+    });
+    if (parsed.flags.has('--json')) {
+        reporter.stdout(JSON.stringify({
+            schema_version: '1',
+            command: 'docs review list',
+            ledger_path: DOC_REVIEW_LEDGER_RELATIVE_PATH,
+            count: entries.length,
+            documents: entries,
+        }, null, 2));
+        return 0;
+    }
+    reporter.stdout(renderEntries(entries, lang));
+    return 0;
+}
+/**
+ * mf:anchor cli.docs.review-add
+ * purpose: Add LLM-modified or generated documentation to the review queue with optional comments.
+ * search: docs review add, review ledger, actor kind, comment file, documentation queue
+ * invariant: Imported comment files are removed only after the review entry is recorded.
+ * risk: state, data_consistency
+ */
+function runReviewAdd(args, reporter, lang) {
+    const parsed = parseOptions(args, ADD_VALUE_OPTIONS, new Set());
+    if (parsed.error) {
+        const message = parsed.error.missingValue
+            ? t(lang, 'cli.error.missingValue', { option: parsed.error.option })
+            : t(lang, 'cli.error.unknownOption', { option: parsed.error.option });
+        return usageError(reporter, message, lang);
+    }
+    const [documentPath, unexpected] = parsed.positionals;
+    if (!documentPath) {
+        return usageError(reporter, t(lang, 'docs.error.missingPath'), lang);
+    }
+    if (unexpected) {
+        return usageError(reporter, t(lang, 'cli.error.unexpectedArgument', { argument: unexpected }), lang);
+    }
+    const actorKind = parseReviewerKind(parsed.values.get('--actor-kind'));
+    if (parsed.values.has('--actor-kind') && !actorKind) {
+        return usageError(reporter, t(lang, 'docs.error.invalidReviewerKind', { kinds: REVIEWER_KINDS.join(', ') }), lang);
+    }
+    const projectRoot = resolveMustflowRoot();
+    const commentResult = readReviewComment(projectRoot, parsed, lang);
+    if (commentResult.error) {
+        return usageError(reporter, commentResult.error, lang);
+    }
+    const commentFileError = ensureCommentFileIsNotDocument(projectRoot, documentPath, commentResult.importedCommentFilePath, lang);
+    if (commentFileError) {
+        return usageError(reporter, commentFileError, lang);
+    }
+    const entry = addDocReviewEntry(projectRoot, {
+        path: documentPath,
+        reason: parsed.values.get('--reason'),
+        origin: parsed.values.get('--origin'),
+        comment: commentResult.comment,
+        actorKind,
+        actorId: parsed.values.get('--actor-id'),
+    });
+    removeImportedCommentFile(commentResult.importedCommentFilePath);
+    reporter.stdout(renderEntryAction(t(lang, 'docs.review.added'), entry.path, lang));
+    return 0;
+}
+function runReviewComment(args, reporter, lang) {
+    const parsed = parseOptions(args, COMMENT_VALUE_OPTIONS, new Set());
+    if (parsed.error) {
+        const message = parsed.error.missingValue
+            ? t(lang, 'cli.error.missingValue', { option: parsed.error.option })
+            : t(lang, 'cli.error.unknownOption', { option: parsed.error.option });
+        return usageError(reporter, message, lang);
+    }
+    const [documentPath, unexpected] = parsed.positionals;
+    if (!documentPath) {
+        return usageError(reporter, t(lang, 'docs.error.missingPath'), lang);
+    }
+    if (unexpected) {
+        return usageError(reporter, t(lang, 'cli.error.unexpectedArgument', { argument: unexpected }), lang);
+    }
+    const actorKind = parseReviewerKind(parsed.values.get('--actor-kind'));
+    if (parsed.values.has('--actor-kind') && !actorKind) {
+        return usageError(reporter, t(lang, 'docs.error.invalidReviewerKind', { kinds: REVIEWER_KINDS.join(', ') }), lang);
+    }
+    const projectRoot = resolveMustflowRoot();
+    const commentResult = readReviewComment(projectRoot, parsed, lang);
+    if (commentResult.error) {
+        return usageError(reporter, commentResult.error, lang);
+    }
+    const commentFileError = ensureCommentFileIsNotDocument(projectRoot, documentPath, commentResult.importedCommentFilePath, lang);
+    if (commentFileError) {
+        return usageError(reporter, commentFileError, lang);
+    }
+    if (!commentResult.comment) {
+        return usageError(reporter, t(lang, 'docs.error.missingComment'), lang);
+    }
+    try {
+        const entry = commentDocReviewEntry(projectRoot, {
+            path: documentPath,
+            comment: commentResult.comment,
+            actorKind,
+            actorId: parsed.values.get('--actor-id'),
+        });
+        removeImportedCommentFile(commentResult.importedCommentFilePath);
+        reporter.stdout(renderEntryAction(t(lang, 'docs.review.commented'), entry.path, lang));
+        return 0;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        reporter.stderr(renderCliError(message, 'mf docs --help', lang));
+        return 1;
+    }
+}
+function runReviewMark(args, status, reporter, lang) {
+    const parsed = parseOptions(args, REVIEW_VALUE_OPTIONS, new Set());
+    if (parsed.error) {
+        const message = parsed.error.missingValue
+            ? t(lang, 'cli.error.missingValue', { option: parsed.error.option })
+            : t(lang, 'cli.error.unknownOption', { option: parsed.error.option });
+        return usageError(reporter, message, lang);
+    }
+    const [documentPath, unexpected] = parsed.positionals;
+    if (!documentPath) {
+        return usageError(reporter, t(lang, 'docs.error.missingPath'), lang);
+    }
+    if (unexpected) {
+        return usageError(reporter, t(lang, 'cli.error.unexpectedArgument', { argument: unexpected }), lang);
+    }
+    const reviewerKind = parseReviewerKind(parsed.values.get('--reviewer-kind'));
+    if (!reviewerKind) {
+        const key = parsed.values.has('--reviewer-kind') ? 'docs.error.invalidReviewerKind' : 'docs.error.missingReviewerKind';
+        return usageError(reporter, t(lang, key, { kinds: REVIEWER_KINDS.join(', ') }), lang);
+    }
+    const reviewerId = parsed.values.get('--reviewer-id');
+    if (!reviewerId) {
+        return usageError(reporter, t(lang, 'docs.error.missingReviewerId'), lang);
+    }
+    try {
+        const entry = markDocReviewEntry(resolveMustflowRoot(), {
+            path: documentPath,
+            status,
+            reviewerKind,
+            reviewerId,
+            reviewerLabel: parsed.values.get('--reviewer-label'),
+            reviewerProvider: parsed.values.get('--reviewer-provider'),
+            reviewerModel: parsed.values.get('--reviewer-model'),
+            reviewerCommandIntent: parsed.values.get('--command-intent'),
+            summary: parsed.values.get('--summary'),
+        });
+        reporter.stdout(renderEntryAction(getMarkedAction(status, lang), entry.path, lang));
+        return 0;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        reporter.stderr(renderCliError(message, 'mf docs --help', lang));
+        return 1;
+    }
+}
+export function runDocs(args, reporter, lang = 'en') {
+    if (args.includes('--help') || args.includes('-h')) {
+        reporter.stdout(getDocsHelp(lang));
+        return 0;
+    }
+    const [topic, action, ...rest] = args;
+    if (topic !== 'review') {
+        return usageError(reporter, topic ? t(lang, 'docs.error.unknownTopic', { topic }) : t(lang, 'docs.error.missingTopic'), lang);
+    }
+    if (!action || action === 'list') {
+        return runReviewList(rest, reporter, lang);
+    }
+    if (action === 'add' || action === 'record') {
+        return runReviewAdd(rest, reporter, lang);
+    }
+    if (action === 'comment') {
+        return runReviewComment(rest, reporter, lang);
+    }
+    if (action === 'approve' || action === 'mark-approved') {
+        return runReviewMark(rest, 'approved', reporter, lang);
+    }
+    if (action === 'needs-human' || action === 'mark-needs-human') {
+        return runReviewMark(rest, 'needs_human', reporter, lang);
+    }
+    if (action === 'ignore' || action === 'mark-ignored') {
+        return runReviewMark(rest, 'ignored', reporter, lang);
+    }
+    return usageError(reporter, t(lang, 'docs.error.unknownAction', { action }), lang);
+}

package/dist/cli/commands/doctor.js

@@ -0,0 +1,232 @@
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { printUsageError, renderHelp } from '../lib/cli-output.js';
+import { getAgentContext, } from '../lib/agent-context.js';
+import { t } from '../lib/i18n.js';
+import { getLocalIndexDatabasePath } from '../lib/local-index.js';
+import { resolveMustflowRoot } from '../lib/project-root.js';
+import { checkMustflowProject } from '../lib/validation.js';
+import { summarizeSkillRouteAlignment } from '../../core/skill-route-alignment.js';
+const DOCTOR_SCHEMA_VERSION = '1';
+export function getDoctorHelp(lang = 'en') {
+    return renderHelp({
+        usage: 'mf doctor [options]',
+        summary: t(lang, 'doctor.help.summary'),
+        options: [
+            {
+                label: '--json',
+                description: t(lang, 'doctor.help.option.json'),
+            },
+            {
+                label: '--strict',
+                description: t(lang, 'doctor.help.option.strict'),
+            },
+            { label: '-h, --help', description: t(lang, 'cli.option.help') },
+        ],
+        examples: ['mf doctor', 'mf doctor --json', 'mf doctor --strict --json'],
+        exitCodes: [
+            {
+                label: '0',
+                description: t(lang, 'doctor.help.exit.ok'),
+            },
+            {
+                label: '1',
+                description: t(lang, 'doctor.help.exit.fail'),
+            },
+        ],
+    }, lang);
+}
+function pluralize(count, singular, plural) {
+    return count === 1 ? singular : plural;
+}
+function createDiagnostics(output) {
+    const diagnostics = [];
+    const checkCommand = output.strict ? 'mf check --strict' : 'mf check';
+    const repoMapExists = existsSync(path.join(output.mustflow_root, 'REPO_MAP.md'));
+    const localIndexExists = existsSync(getLocalIndexDatabasePath(output.mustflow_root));
+    const runnableIntentCount = output.context.runnable_intents.length;
+    const skillRouteAlignment = summarizeSkillRouteAlignment(output.check.issues);
+    diagnostics.push({
+        id: 'install',
+        status: output.installed ? 'ok' : 'fail',
+        summary: output.installed ? 'installed' : 'not installed',
+        action: output.installed ? null : 'mf init --dry-run',
+    });
+    diagnostics.push({
+        id: 'validation',
+        status: output.check.ok ? 'ok' : 'fail',
+        summary: `${output.check.issue_count} ${pluralize(output.check.issue_count, 'issue', 'issues')}`,
+        action: output.check.ok ? null : checkCommand,
+    });
+    diagnostics.push({
+        id: 'skill_routes',
+        status: output.strict ? skillRouteAlignment.status : 'info',
+        summary: output.strict ? skillRouteAlignment.summary : 'not evaluated; run strict doctor',
+        action: output.strict ? skillRouteAlignment.action : 'mf doctor --strict --json',
+    });
+    diagnostics.push({
+        id: 'commands',
+        status: output.context.command_contract_exists ? (runnableIntentCount > 0 ? 'ok' : 'warn') : 'fail',
+        summary: output.context.command_contract_exists
+            ? `present, ${runnableIntentCount} runnable ${pluralize(runnableIntentCount, 'intent', 'intents')}`
+            : 'missing',
+        action: output.context.command_contract_exists ? 'mf help commands' : 'mf init --dry-run',
+    });
+    diagnostics.push({
+        id: 'read_order',
+        status: output.context.missing_read_order.length === 0 ? 'ok' : 'fail',
+        summary: output.context.missing_read_order.length === 0
+            ? 'all required files present'
+            : `${output.context.missing_read_order.length} missing required ${pluralize(output.context.missing_read_order.length, 'path', 'paths')}`,
+        action: output.context.missing_read_order.length === 0 ? 'mf context --json' : checkCommand,
+    });
+    if (output.context.missing_optional_read_order.length > 0) {
+        diagnostics.push({
+            id: 'optional_read_order',
+            status: 'info',
+            summary: `${output.context.missing_optional_read_order.length} missing optional ${pluralize(output.context.missing_optional_read_order.length, 'path', 'paths')}`,
+            action: 'mf context --json',
+        });
+    }
+    diagnostics.push({
+        id: 'repo_map',
+        status: repoMapExists ? 'ok' : 'info',
+        summary: repoMapExists ? 'present' : 'not generated',
+        action: repoMapExists ? 'mf map --stdout' : 'mf map --write',
+    });
+    diagnostics.push({
+        id: 'local_index',
+        status: localIndexExists ? 'ok' : 'info',
+        summary: localIndexExists ? 'present' : 'not generated',
+        action: localIndexExists ? 'mf search <query>' : 'mf index',
+    });
+    diagnostics.push({
+        id: 'latest_run',
+        status: output.context.latest_run_exists ? 'ok' : 'info',
+        summary: output.context.latest_run_exists ? 'run receipt present' : 'no run receipt yet',
+        action: output.context.latest_run_exists ? null : 'mf run <intent>',
+    });
+    return diagnostics;
+}
+function getNextSteps(output) {
+    if (!output.installed) {
+        return ['mf init --dry-run', 'mf init --yes'];
+    }
+    if (!output.check.ok) {
+        const checkCommand = output.strict ? 'mf check --strict' : 'mf check';
+        return [checkCommand, 'mf status --json', 'mf update --dry-run'];
+    }
+    const nextSteps = ['mf help workflow', 'mf help commands', 'mf context --json', 'mf check --strict'];
+    for (const diagnostic of output.diagnostics) {
+        if (diagnostic.action && diagnostic.status !== 'ok' && !nextSteps.includes(diagnostic.action)) {
+            nextSteps.push(diagnostic.action);
+        }
+    }
+    return nextSteps;
+}
+function createDoctorOutput(strict) {
+    const mustflowRoot = resolveMustflowRoot();
+    const context = getAgentContext(mustflowRoot);
+    const issues = checkMustflowProject(mustflowRoot, { strict });
+    const check = {
+        ok: issues.length === 0,
+        issue_count: issues.length,
+        issues,
+    };
+    const baseOutput = {
+        schema_version: DOCTOR_SCHEMA_VERSION,
+        command: 'doctor',
+        mustflow_root: mustflowRoot,
+        installed: context.installed,
+        strict,
+        ok: context.installed && check.ok,
+        check,
+        context: {
+            manifest_lock: context.manifest_lock,
+            template: context.template,
+            command_contract_exists: context.command_contract.exists,
+            runnable_intents: context.command_contract.runnable_intents,
+            missing_read_order: context.read_order.filter((entry) => !entry.exists).map((entry) => entry.path),
+            missing_optional_read_order: context.optional_read_order.filter((entry) => !entry.exists).map((entry) => entry.path),
+            latest_run_exists: context.latest_run.exists,
+        },
+        effective_policy: context.effective_policy,
+        state_policy: context.state_policy,
+        blocked_actions: context.blocked_actions,
+    };
+    const diagnostics = createDiagnostics(baseOutput);
+    return {
+        ...baseOutput,
+        diagnostics,
+        next_steps: getNextSteps({ ...baseOutput, diagnostics }),
+    };
+}
+function getDiagnosticLabel(id, lang) {
+    switch (id) {
+        case 'install':
+            return t(lang, 'doctor.diagnostic.install');
+        case 'validation':
+            return t(lang, 'doctor.diagnostic.validation');
+        case 'skill_routes':
+            return t(lang, 'doctor.diagnostic.skillRoutes');
+        case 'commands':
+            return t(lang, 'doctor.diagnostic.commands');
+        case 'read_order':
+            return t(lang, 'doctor.diagnostic.readOrder');
+        case 'optional_read_order':
+            return t(lang, 'doctor.diagnostic.optionalReadOrder');
+        case 'repo_map':
+            return t(lang, 'doctor.diagnostic.repoMap');
+        case 'local_index':
+            return t(lang, 'doctor.diagnostic.localIndex');
+        case 'latest_run':
+            return t(lang, 'doctor.diagnostic.latestRun');
+    }
+}
+function renderDoctorOutput(output, lang) {
+    const lines = [];
+    lines.push(t(lang, 'doctor.title'));
+    lines.push(`${t(lang, 'label.mustflowRoot')}: ${output.mustflow_root}`);
+    lines.push(`${t(lang, 'label.installed')}: ${output.installed ? 'yes' : 'no'}`);
+    lines.push(`${t(lang, 'doctor.label.strict')}: ${output.strict ? 'yes' : 'no'}`);
+    lines.push(`${t(lang, 'doctor.label.check')}: ${output.check.ok ? 'passed' : 'failed'}`);
+    lines.push(`${t(lang, 'doctor.label.issues')}: ${output.check.issue_count}`);
+    lines.push(`${t(lang, 'label.commandContract')}: ${output.context.command_contract_exists ? 'present' : 'missing'}`);
+    lines.push(`${t(lang, 'label.runnableIntents')}: ${output.context.runnable_intents.length}`);
+    lines.push('', t(lang, 'doctor.section.health'));
+    for (const diagnostic of output.diagnostics) {
+        const action = diagnostic.action && diagnostic.status !== 'ok' ? ` (${t(lang, 'doctor.actionLabel')}: ${diagnostic.action})` : '';
+        lines.push(`- [${diagnostic.status}] ${getDiagnosticLabel(diagnostic.id, lang)}: ${diagnostic.summary}${action}`);
+    }
+    if (output.check.issues.length > 0) {
+        lines.push('', t(lang, 'doctor.section.issueList'));
+        for (const issue of output.check.issues) {
+            lines.push(`- ${issue}`);
+        }
+    }
+    lines.push('', t(lang, 'doctor.section.suggestedCommands'));
+    for (const step of output.next_steps) {
+        lines.push(`- ${step}`);
+    }
+    lines.push('', t(lang, 'update.plan.noFilesWritten'));
+    return lines.join('\n');
+}
+export function runDoctor(args, reporter, lang = 'en') {
+    if (args.includes('--help') || args.includes('-h')) {
+        reporter.stdout(getDoctorHelp(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 doctor --help', getDoctorHelp(lang), lang);
+        return 1;
+    }
+    const output = createDoctorOutput(args.includes('--strict'));
+    if (args.includes('--json')) {
+        reporter.stdout(JSON.stringify(output, null, 2));
+        return output.ok ? 0 : 1;
+    }
+    reporter.stdout(renderDoctorOutput(output, lang));
+    return output.ok ? 0 : 1;
+}