mustflow 2.23.0 → 2.24.2

package/dist/cli/commands/workspace.js

@@ -0,0 +1,564 @@
+import path from 'node:path';
+import { createClassifyOutput } from './classify.js';
+import { createChangeVerificationReport, } from '../../core/change-verification.js';
+import { createVerificationPlanId } from '../../core/verification-plan-id.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';
+import { getRepoMapConfig, discoverNestedRepositories } from '../lib/repo-map.js';
+import { createRunPlan } from '../lib/run-plan.js';
+import { readCommandContract, readString, readStringArray } from '../../core/config-loading.js';
+const WORKSPACE_STATUS_SCHEMA_VERSION = '1';
+const WORKSPACE_COMMAND_CATALOG_SCHEMA_VERSION = '1';
+const WORKSPACE_VERIFICATION_PLAN_SCHEMA_VERSION = '1';
+const WORKSPACE_STATUS_OPTIONS = [{ name: '--json', kind: 'boolean' }];
+const WORKSPACE_COMMAND_CATALOG_OPTIONS = [{ name: '--json', kind: 'boolean' }];
+const WORKSPACE_VERIFY_OPTIONS = [
+    { name: '--changed', kind: 'boolean' },
+    { name: '--plan-only', kind: 'boolean' },
+    { name: '--json', kind: 'boolean' },
+];
+function getWorkspaceHelp(lang = 'en') {
+    return renderHelp({
+        usage: 'mf workspace <action> [options]',
+        summary: t(lang, 'workspace.help.summary'),
+        commands: [
+            { label: 'status', description: t(lang, 'workspace.help.action.status') },
+            { label: 'command-catalog', description: t(lang, 'workspace.help.action.commandCatalog') },
+            { label: 'verify', description: t(lang, 'workspace.help.action.verify') },
+        ],
+        options: [
+            { label: '--changed', description: t(lang, 'classify.help.option.changed') },
+            { label: '--plan-only', description: t(lang, 'verify.help.option.planOnly') },
+            { label: '--json', description: t(lang, 'cli.option.json') },
+            { label: '-h, --help', description: t(lang, 'cli.option.help') },
+        ],
+        examples: [
+            'mf workspace status --json',
+            'mf workspace command-catalog --json',
+            'mf workspace verify --changed --plan-only --json',
+        ],
+        exitCodes: [
+            { label: '0', description: t(lang, 'workspace.help.exit.ok') },
+            { label: '1', description: t(lang, 'cli.common.invalidInput') },
+        ],
+    }, lang);
+}
+function createWorkspaceStatusPolicy() {
+    return {
+        mode: 'read_only',
+        grants_command_authority: false,
+        parent_root_grants_child_authority: false,
+        command_authority_per_root: '.mustflow/config/commands.toml',
+        run_entrypoint_per_root: 'mf run <intent>',
+        executes_commands: false,
+        raw_commands_included: false,
+    };
+}
+function createWorkspaceVerificationPlanPolicy() {
+    return {
+        ...createWorkspaceStatusPolicy(),
+        plan_command_per_root: 'mf verify --changed --plan-only --json',
+        selected_intents_run_via: 'mf run <intent>',
+    };
+}
+function getIntentNames(intents) {
+    return Object.keys(intents).sort((left, right) => left.localeCompare(right));
+}
+function summarizeCommandSurface(repositoryRoot, repository) {
+    if (!repository.commandContract) {
+        return {
+            path: null,
+            exists: false,
+            parse_error: null,
+            total_intents: null,
+            runnable_count: null,
+            runnable_intents: [],
+            blocked_count: null,
+        };
+    }
+    try {
+        const contract = readCommandContract(repositoryRoot);
+        const intentNames = getIntentNames(contract.intents);
+        const runnableIntents = intentNames.filter((intentName) => createRunPlan(repositoryRoot, contract, intentName).ok);
+        return {
+            path: repository.commandContract,
+            exists: true,
+            parse_error: null,
+            total_intents: intentNames.length,
+            runnable_count: runnableIntents.length,
+            runnable_intents: runnableIntents,
+            blocked_count: Math.max(0, intentNames.length - runnableIntents.length),
+        };
+    }
+    catch (error) {
+        return {
+            path: repository.commandContract,
+            exists: true,
+            parse_error: error instanceof Error ? error.message : String(error),
+            total_intents: null,
+            runnable_count: null,
+            runnable_intents: [],
+            blocked_count: null,
+        };
+    }
+}
+function repositoryStatus(commandSurface) {
+    if (!commandSurface.exists) {
+        return 'contract_missing';
+    }
+    if (commandSurface.parse_error) {
+        return 'contract_invalid';
+    }
+    return 'mustflow_ready';
+}
+function summarizeRepository(projectRoot, repository) {
+    const repositoryRoot = path.resolve(projectRoot, repository.relativePath);
+    const commandSurface = summarizeCommandSurface(repositoryRoot, repository);
+    const issues = commandSurface.parse_error ? [commandSurface.parse_error] : [];
+    return {
+        relative_path: repository.relativePath,
+        status: repositoryStatus(commandSurface),
+        git_repository: true,
+        mustflow: repository.mustflow,
+        agent_rules: repository.agentRules ?? null,
+        repo_map: repository.repoMap ?? null,
+        mustflow_config: repository.mustflowConfig ?? null,
+        command_contract: commandSurface,
+        context_index: repository.contextIndex ?? null,
+        skill_index: repository.skillIndex ?? null,
+        root_document_count: repository.rootDocuments.length,
+        machine_contract_count: repository.machineContracts.length,
+        manifest_count: repository.manifests.length,
+        command_adapter_count: repository.commandAdapters.length,
+        editing_policy_count: repository.editingPolicies.length,
+        issues,
+    };
+}
+function createWorkspaceStatusOutput() {
+    const projectRoot = resolveMustflowRoot();
+    const config = getRepoMapConfig(projectRoot);
+    const nestedRepositories = discoverNestedRepositories(projectRoot, { ...config.map, includeNested: true }, config.workspace);
+    const repositories = nestedRepositories.map((repository) => summarizeRepository(projectRoot, repository));
+    const issues = config.workspace.enabled && config.workspace.roots.length > 0 && repositories.length === 0
+        ? ['No nested git repositories were discovered under configured workspace roots.']
+        : [];
+    return {
+        schema_version: WORKSPACE_STATUS_SCHEMA_VERSION,
+        command: 'workspace status',
+        mustflow_root: projectRoot,
+        workspace: {
+            enabled: config.workspace.enabled,
+            roots: config.workspace.roots,
+            max_depth: config.workspace.maxDepth,
+            max_repositories: config.workspace.maxRepositories,
+            follow_symlinks: config.workspace.followSymlinks,
+            stop_at_repository_root: config.workspace.stopAtRepositoryRoot,
+        },
+        policy: createWorkspaceStatusPolicy(),
+        repository_count: repositories.length,
+        repositories,
+        issues,
+    };
+}
+function readWorkspaceRepositories(projectRoot) {
+    const config = getRepoMapConfig(projectRoot);
+    return {
+        config,
+        repositories: discoverNestedRepositories(projectRoot, { ...config.map, includeNested: true }, config.workspace),
+    };
+}
+function workspaceConfigOutput(config) {
+    return {
+        enabled: config.workspace.enabled,
+        roots: config.workspace.roots,
+        max_depth: config.workspace.maxDepth,
+        max_repositories: config.workspace.maxRepositories,
+        follow_symlinks: config.workspace.followSymlinks,
+        stop_at_repository_root: config.workspace.stopAtRepositoryRoot,
+    };
+}
+function createWorkspaceIssues(config, repositoryCount) {
+    return config.workspace.enabled && config.workspace.roots.length > 0 && repositoryCount === 0
+        ? ['No nested git repositories were discovered under configured workspace roots.']
+        : [];
+}
+function readIntentStrings(rawIntent, key) {
+    return readStringArray(intentTable(rawIntent), key) ?? [];
+}
+function readIntentBoolean(rawIntent, key) {
+    const value = intentTable(rawIntent)[key];
+    return typeof value === 'boolean' ? value : null;
+}
+function intentTable(rawIntent) {
+    return rawIntent && typeof rawIntent === 'object' && !Array.isArray(rawIntent) ? rawIntent : {};
+}
+function readIntentString(rawIntent, key) {
+    return readString(intentTable(rawIntent), key) ?? null;
+}
+function safeRunCommand(intentName) {
+    return /^[A-Za-z0-9_-]+$/u.test(intentName) ? `mf run ${intentName}` : null;
+}
+function createCatalogIntent(repositoryRoot, repositoryPath, contract, intentName) {
+    const rawIntent = contract.intents[intentName];
+    try {
+        const plan = createRunPlan(repositoryRoot, contract, intentName);
+        return {
+            name: intentName,
+            description: readIntentString(rawIntent, 'description'),
+            status: plan.intentStatus,
+            lifecycle: plan.lifecycle,
+            run_policy: plan.runPolicy,
+            runnable: plan.ok,
+            reason_code: plan.reasonCode,
+            detail: plan.detail,
+            run_command: plan.ok ? `mf run ${intentName}` : null,
+            run_from_repository: repositoryPath,
+            timeout_seconds: plan.timeoutSeconds,
+            required_after: readIntentStrings(rawIntent, 'required_after'),
+            writes: plan.writes ?? [],
+            network: readIntentBoolean(rawIntent, 'network'),
+            destructive: readIntentBoolean(rawIntent, 'destructive'),
+        };
+    }
+    catch (error) {
+        return {
+            name: intentName,
+            description: readIntentString(rawIntent, 'description'),
+            status: readIntentString(rawIntent, 'status'),
+            lifecycle: readIntentString(rawIntent, 'lifecycle'),
+            run_policy: readIntentString(rawIntent, 'run_policy'),
+            runnable: false,
+            reason_code: 'plan_error',
+            detail: error instanceof Error ? error.message : String(error),
+            run_command: null,
+            run_from_repository: repositoryPath,
+            timeout_seconds: null,
+            required_after: readIntentStrings(rawIntent, 'required_after'),
+            writes: readIntentStrings(rawIntent, 'writes'),
+            network: readIntentBoolean(rawIntent, 'network'),
+            destructive: readIntentBoolean(rawIntent, 'destructive'),
+        };
+    }
+}
+function createCatalogRepository(projectRoot, repository) {
+    const repositoryRoot = path.resolve(projectRoot, repository.relativePath);
+    const commandSurface = summarizeCommandSurface(repositoryRoot, repository);
+    if (!repository.commandContract) {
+        return {
+            relative_path: repository.relativePath,
+            status: 'contract_missing',
+            command_contract: commandSurface,
+            intent_count: 0,
+            runnable_count: 0,
+            blocked_count: 0,
+            intents: [],
+            issues: ['Command contract is missing.'],
+        };
+    }
+    let contract;
+    try {
+        contract = readCommandContract(repositoryRoot);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            relative_path: repository.relativePath,
+            status: 'contract_invalid',
+            command_contract: commandSurface,
+            intent_count: 0,
+            runnable_count: 0,
+            blocked_count: 0,
+            intents: [],
+            issues: [message],
+        };
+    }
+    const intents = getIntentNames(contract.intents).map((intentName) => createCatalogIntent(repositoryRoot, repository.relativePath, contract, intentName));
+    const runnableCount = intents.filter((intent) => intent.runnable).length;
+    return {
+        relative_path: repository.relativePath,
+        status: 'available',
+        command_contract: commandSurface,
+        intent_count: intents.length,
+        runnable_count: runnableCount,
+        blocked_count: Math.max(0, intents.length - runnableCount),
+        intents,
+        issues: [],
+    };
+}
+function createWorkspaceCommandCatalogOutput() {
+    const projectRoot = resolveMustflowRoot();
+    const { config, repositories: nestedRepositories } = readWorkspaceRepositories(projectRoot);
+    const repositories = nestedRepositories.map((repository) => createCatalogRepository(projectRoot, repository));
+    return {
+        schema_version: WORKSPACE_COMMAND_CATALOG_SCHEMA_VERSION,
+        command: 'workspace command-catalog',
+        mustflow_root: projectRoot,
+        workspace: workspaceConfigOutput(config),
+        policy: createWorkspaceStatusPolicy(),
+        repository_count: repositories.length,
+        total_intent_count: repositories.reduce((total, repository) => total + repository.intent_count, 0),
+        runnable_intent_count: repositories.reduce((total, repository) => total + repository.runnable_count, 0),
+        repositories,
+        issues: createWorkspaceIssues(config, repositories.length),
+    };
+}
+function createUnavailableVerificationRepository(repository, commandSurface, status, classification, issue) {
+    return {
+        relative_path: repository.relativePath,
+        status,
+        command_contract: commandSurface,
+        changed_file_count: classification ? classification.summary.fileCount : null,
+        changed_files: classification ? classification.files : [],
+        verification_plan_id: null,
+        requirement_count: 0,
+        candidate_count: 0,
+        selected_intent_count: 0,
+        gap_count: 0,
+        selected_intents: [],
+        gaps: [],
+        issues: [issue],
+    };
+}
+function selectedIntentsForVerificationReport(repositoryPath, report) {
+    return report.schedule.entries.map((entry) => ({
+        intent: entry.intent,
+        run_command: safeRunCommand(entry.intent),
+        run_from_repository: repositoryPath,
+        locks: entry.locks,
+        conflict_count: entry.conflicts.length,
+    }));
+}
+function createVerificationRepository(projectRoot, repository) {
+    const repositoryRoot = path.resolve(projectRoot, repository.relativePath);
+    const commandSurface = summarizeCommandSurface(repositoryRoot, repository);
+    let classification = null;
+    try {
+        classification = createClassifyOutput(repositoryRoot, 'changed', []);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return createUnavailableVerificationRepository(repository, commandSurface, 'git_unavailable', null, message);
+    }
+    if (!repository.commandContract) {
+        return createUnavailableVerificationRepository(repository, commandSurface, 'contract_missing', classification, 'Command contract is missing.');
+    }
+    let contract;
+    try {
+        contract = readCommandContract(repositoryRoot);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return createUnavailableVerificationRepository(repository, commandSurface, 'contract_invalid', classification, message);
+    }
+    let report;
+    try {
+        report = createChangeVerificationReport(classification, contract, repositoryRoot);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return createUnavailableVerificationRepository(repository, commandSurface, 'plan_unavailable', classification, message);
+    }
+    return {
+        relative_path: repository.relativePath,
+        status: 'available',
+        command_contract: commandSurface,
+        changed_file_count: classification.summary.fileCount,
+        changed_files: classification.files,
+        verification_plan_id: createVerificationPlanId(report, contract),
+        requirement_count: report.requirements.length,
+        candidate_count: report.candidates.length,
+        selected_intent_count: report.schedule.entries.length,
+        gap_count: report.gaps.length,
+        selected_intents: selectedIntentsForVerificationReport(repository.relativePath, report),
+        gaps: report.gaps.map((gap) => ({
+            reason: gap.reason,
+            files: gap.files,
+            surfaces: gap.surfaces,
+            detail: gap.detail,
+        })),
+        issues: [],
+    };
+}
+function createWorkspaceVerificationPlanOutput() {
+    const projectRoot = resolveMustflowRoot();
+    const { config, repositories: nestedRepositories } = readWorkspaceRepositories(projectRoot);
+    const repositories = nestedRepositories.map((repository) => createVerificationRepository(projectRoot, repository));
+    return {
+        schema_version: WORKSPACE_VERIFICATION_PLAN_SCHEMA_VERSION,
+        command: 'workspace verify',
+        mustflow_root: projectRoot,
+        workspace: workspaceConfigOutput(config),
+        policy: createWorkspaceVerificationPlanPolicy(),
+        repository_count: repositories.length,
+        total_changed_file_count: repositories.reduce((total, repository) => total + (repository.changed_file_count ?? 0), 0),
+        total_requirement_count: repositories.reduce((total, repository) => total + repository.requirement_count, 0),
+        total_selected_intent_count: repositories.reduce((total, repository) => total + repository.selected_intent_count, 0),
+        total_gap_count: repositories.reduce((total, repository) => total + repository.gap_count, 0),
+        repositories,
+        issues: createWorkspaceIssues(config, repositories.length),
+    };
+}
+function renderWorkspaceStatus(output) {
+    const lines = [
+        'mustflow workspace status',
+        `mustflow root: ${output.mustflow_root}`,
+        `workspace enabled: ${output.workspace.enabled ? 'yes' : 'no'}`,
+        `configured roots: ${output.workspace.roots.length > 0 ? output.workspace.roots.join(', ') : 'none'}`,
+        `repositories: ${output.repository_count}`,
+        '',
+    ];
+    if (output.repositories.length === 0) {
+        lines.push('No nested repositories discovered.');
+        return lines.join('\n');
+    }
+    for (const repository of output.repositories) {
+        lines.push(`- ${repository.relative_path} (${repository.status})`);
+        lines.push(`  mustflow: ${repository.mustflow ? 'yes' : 'no'}`);
+        lines.push(`  command contract: ${repository.command_contract.path ?? 'missing'}`);
+        if (repository.command_contract.runnable_count !== null) {
+            lines.push(`  runnable intents: ${repository.command_contract.runnable_count}`);
+        }
+        if (repository.issues.length > 0) {
+            lines.push(`  issues: ${repository.issues.join('; ')}`);
+        }
+    }
+    return lines.join('\n');
+}
+function renderWorkspaceCommandCatalog(output) {
+    const lines = [
+        'mustflow workspace command-catalog',
+        `mustflow root: ${output.mustflow_root}`,
+        `workspace enabled: ${output.workspace.enabled ? 'yes' : 'no'}`,
+        `repositories: ${output.repository_count}`,
+        `intents: ${output.total_intent_count}`,
+        `runnable intents: ${output.runnable_intent_count}`,
+        '',
+    ];
+    if (output.repositories.length === 0) {
+        lines.push('No nested repositories discovered.');
+        return lines.join('\n');
+    }
+    for (const repository of output.repositories) {
+        lines.push(`- ${repository.relative_path} (${repository.status})`);
+        if (repository.intents.length === 0) {
+            lines.push(`  intents: none`);
+        }
+        for (const intent of repository.intents) {
+            lines.push(`  - ${intent.name}: ${intent.runnable ? 'runnable' : intent.reason_code ?? 'blocked'}`);
+        }
+        if (repository.issues.length > 0) {
+            lines.push(`  issues: ${repository.issues.join('; ')}`);
+        }
+    }
+    return lines.join('\n');
+}
+function renderWorkspaceVerificationPlan(output) {
+    const lines = [
+        'mustflow workspace verify',
+        `mustflow root: ${output.mustflow_root}`,
+        `workspace enabled: ${output.workspace.enabled ? 'yes' : 'no'}`,
+        `repositories: ${output.repository_count}`,
+        `changed files: ${output.total_changed_file_count}`,
+        `requirements: ${output.total_requirement_count}`,
+        `selected intents: ${output.total_selected_intent_count}`,
+        `gaps: ${output.total_gap_count}`,
+        '',
+    ];
+    if (output.repositories.length === 0) {
+        lines.push('No nested repositories discovered.');
+        return lines.join('\n');
+    }
+    for (const repository of output.repositories) {
+        lines.push(`- ${repository.relative_path} (${repository.status})`);
+        lines.push(`  changed files: ${repository.changed_file_count ?? 'unknown'}`);
+        lines.push(`  selected intents: ${repository.selected_intent_count}`);
+        for (const selected of repository.selected_intents) {
+            lines.push(`  - ${selected.intent}: ${selected.run_command ?? 'unavailable'}`);
+        }
+        if (repository.gaps.length > 0) {
+            lines.push(`  gaps: ${repository.gaps.map((gap) => gap.reason).join(', ')}`);
+        }
+        if (repository.issues.length > 0) {
+            lines.push(`  issues: ${repository.issues.join('; ')}`);
+        }
+    }
+    return lines.join('\n');
+}
+function runWorkspaceStatus(args, reporter, lang) {
+    if (hasCliOptionToken(args, '--help', ['-h'])) {
+        reporter.stdout(getWorkspaceHelp(lang));
+        return 0;
+    }
+    const parsed = parseCliOptions(args, WORKSPACE_STATUS_OPTIONS);
+    if (parsed.error) {
+        printUsageError(reporter, formatCliOptionParseError(parsed.error, lang), 'mf workspace --help', getWorkspaceHelp(lang), lang);
+        return 1;
+    }
+    const output = createWorkspaceStatusOutput();
+    reporter.stdout(hasParsedCliOption(parsed, '--json') ? JSON.stringify(output, null, 2) : renderWorkspaceStatus(output));
+    return 0;
+}
+function runWorkspaceCommandCatalog(args, reporter, lang) {
+    if (hasCliOptionToken(args, '--help', ['-h'])) {
+        reporter.stdout(getWorkspaceHelp(lang));
+        return 0;
+    }
+    const parsed = parseCliOptions(args, WORKSPACE_COMMAND_CATALOG_OPTIONS);
+    if (parsed.error) {
+        printUsageError(reporter, formatCliOptionParseError(parsed.error, lang), 'mf workspace --help', getWorkspaceHelp(lang), lang);
+        return 1;
+    }
+    const output = createWorkspaceCommandCatalogOutput();
+    reporter.stdout(hasParsedCliOption(parsed, '--json') ? JSON.stringify(output, null, 2) : renderWorkspaceCommandCatalog(output));
+    return 0;
+}
+function runWorkspaceVerify(args, reporter, lang) {
+    if (hasCliOptionToken(args, '--help', ['-h'])) {
+        reporter.stdout(getWorkspaceHelp(lang));
+        return 0;
+    }
+    const parsed = parseCliOptions(args, WORKSPACE_VERIFY_OPTIONS);
+    if (parsed.error) {
+        printUsageError(reporter, formatCliOptionParseError(parsed.error, lang), 'mf workspace --help', getWorkspaceHelp(lang), lang);
+        return 1;
+    }
+    if (!hasParsedCliOption(parsed, '--changed')) {
+        printUsageError(reporter, t(lang, 'workspace.error.verifyRequiresChanged'), 'mf workspace --help', getWorkspaceHelp(lang), lang);
+        return 1;
+    }
+    if (!hasParsedCliOption(parsed, '--plan-only')) {
+        printUsageError(reporter, t(lang, 'workspace.error.verifyRequiresPlanOnly'), 'mf workspace --help', getWorkspaceHelp(lang), lang);
+        return 1;
+    }
+    const output = createWorkspaceVerificationPlanOutput();
+    reporter.stdout(hasParsedCliOption(parsed, '--json') ? JSON.stringify(output, null, 2) : renderWorkspaceVerificationPlan(output));
+    return 0;
+}
+export function runWorkspace(args, reporter, lang = 'en') {
+    if (hasCliOptionToken(args, '--help', ['-h'])) {
+        reporter.stdout(getWorkspaceHelp(lang));
+        return 0;
+    }
+    const [action, ...rest] = args;
+    if (!action) {
+        printUsageError(reporter, t(lang, 'workspace.error.missingAction'), 'mf workspace --help', getWorkspaceHelp(lang), lang);
+        return 1;
+    }
+    if (action.startsWith('-')) {
+        printUsageError(reporter, t(lang, 'cli.error.unknownOption', { option: action }), 'mf workspace --help', getWorkspaceHelp(lang), lang);
+        return 1;
+    }
+    if (action === 'status') {
+        return runWorkspaceStatus(rest, reporter, lang);
+    }
+    if (action === 'command-catalog') {
+        return runWorkspaceCommandCatalog(rest, reporter, lang);
+    }
+    if (action === 'verify') {
+        return runWorkspaceVerify(rest, reporter, lang);
+    }
+    printUsageError(reporter, t(lang, 'workspace.error.unknownAction', { action }), 'mf workspace --help', getWorkspaceHelp(lang), lang);
+    return 1;
+}

package/dist/cli/i18n/en.js

@@ -30,6 +30,10 @@ export const enMessages = {
     "command.check.summary": "Validate mustflow files",
     "command.classify.summary": "Classify changed files and public surfaces",
     "command.contractLint.summary": "Lint the command contract",
+    "command.onboard.summary": "Suggest review-only command onboarding snippets",
+    "command.next.summary": "Choose the next safe mustflow action",
+    "command.evidence.summary": "Summarize verification requirements, evidence, and gaps",
+    "command.workspace.summary": "Inspect configured workspace roots and nested repository contracts",
     "command.status.summary": "Show local mustflow install status",
     "command.update.summary": "Preview or apply mustflow workflow updates",
     "command.upgrade.summary": "Check the package version and safely update installed workflow files",
@@ -82,6 +86,58 @@ export const enMessages = {
     "contractLint.label.coverageFindings": "Coverage findings",
     "contractLint.label.suggestions": "Suggestions",
     "contractLint.label.issues": "Issues",
+    "onboard.help.summary": "Suggest review-only command-intent snippets from existing package, Make, and just command files.",
+    "onboard.help.exit.ok": "Command onboarding suggestions were inspected",
+    "onboard.help.exit.fail": "The onboard command received invalid input",
+    "onboard.title": "mustflow command onboarding",
+    "onboard.label.suggestions": "Suggestions",
+    "onboard.label.reviewOnly": "Review only",
+    "onboard.label.writesFiles": "Writes files",
+    "onboard.label.reviewSnippets": "Review-only snippets",
+    "onboard.label.nextSteps": "Next steps",
+    "onboard.error.missingAction": "Specify an onboard action: commands",
+    "onboard.error.unknownAction": "Unknown onboard action: {action}",
+    "next.help.summary": "Inspect the current root and changed files, then print the next safe mustflow action.",
+    "next.help.exit.ok": "Next action was inspected",
+    "next.help.exit.fail": "The next action could not be inspected",
+    "next.title": "mustflow next",
+    "next.label.status": "Status",
+    "next.label.nextAction": "Next action",
+    "next.label.reason": "Reason",
+    "next.label.selectedIntents": "Selected verification",
+    "next.label.gaps": "Gaps",
+    "next.section.gaps": "Verification gaps",
+    "next.section.blockers": "Blockers",
+    "next.section.warnings": "Warnings",
+    "next.section.commands": "Recommended commands",
+    "evidence.help.summary": "Summarize changed-file verification requirements, latest evidence, receipts, and remaining gaps without running commands.",
+    "evidence.help.option.changed": "Build an evidence report from the current changed-file verification plan",
+    "evidence.help.option.latest": "Summarize only the latest stored run or verify evidence",
+    "evidence.help.option.plan": "Build an evidence report from a saved mustflow verification-plan JSON file",
+    "evidence.help.option.export": "Write the evidence report JSON to a path inside the mustflow root",
+    "evidence.help.exit.ok": "Evidence was inspected",
+    "evidence.help.exit.fail": "Evidence could not be inspected",
+    "evidence.error.conflictingInputs": "Choose only one evidence source: --changed, --latest, or --plan",
+    "evidence.title": "mustflow evidence",
+    "evidence.label.status": "Status",
+    "evidence.label.source": "Source",
+    "evidence.label.plan": "Verification plan",
+    "evidence.label.requirements": "Requirements",
+    "evidence.label.selectedIntents": "Selected intents",
+    "evidence.label.gaps": "Gaps",
+    "evidence.label.latest": "Latest evidence",
+    "evidence.section.requirements": "Requirements",
+    "evidence.section.gaps": "Gaps",
+    "evidence.section.remainingRisks": "Remaining risks",
+    "workspace.help.summary": "Inspect configured workspace roots and nested repository contract readiness without granting command authority.",
+    "workspace.help.action.status": "Print discovered nested repositories and their local mustflow contract status",
+    "workspace.help.action.commandCatalog": "Print per-repository command intent availability without raw command strings",
+    "workspace.help.action.verify": "Print per-repository changed-file verification plans without running commands",
+    "workspace.help.exit.ok": "Workspace status was inspected",
+    "workspace.error.missingAction": "Specify a workspace action: status, command-catalog, or verify",
+    "workspace.error.unknownAction": "Unknown workspace action: {action}",
+    "workspace.error.verifyRequiresChanged": "workspace verify requires --changed",
+    "workspace.error.verifyRequiresPlanOnly": "workspace verify requires --plan-only",
     "context.help.summary": "Print the agent context for the current mustflow root.",
     "context.help.option.json": "Print machine-readable context JSON",
     "context.help.option.cacheProfile": "Print a prompt-cache profile: stable, task, volatile, or all",
@@ -95,11 +151,14 @@ export const enMessages = {
     "api.help.action.diffRisk": "Print a compact changed-file risk and verification summary",
     "api.help.action.health": "Print a compact workspace health summary",
     "api.help.action.locks": "Print active mf run locks for multi-session coordination",
+    "api.help.action.serve": "Serve read-only API reports over newline-delimited stdio",
+    "api.help.option.stdio": "Read newline-delimited JSON requests from stdin and print JSON responses",
     "api.help.exit.ok": "The API report was inspected and printed",
-    "api.error.missingAction": "Specify an api action: workspace-summary, command-catalog, verification-plan, latest-evidence, diff-risk, health, or locks",
+    "api.error.missingAction": "Specify an api action: workspace-summary, command-catalog, verification-plan, latest-evidence, diff-risk, health, locks, or serve",
     "api.error.unknownAction": "Unknown api action: {action}",
     "api.error.actionRequiresJson": "{action} requires --json",
     "api.error.actionRequiresChanged": "{action} currently requires --changed",
+    "api.error.serveRequiresStdio": "api serve requires --stdio",
     "label.installed": "Installed",
     "label.mustflowRoot": "mustflow root",
     "label.commandContract": "Command specification",