@memoarchitect/tools 0.13.0 → 0.15.0

package/packages/tools/lib/bin/memo.js

@@ -1,53 +1,39 @@
 #!/usr/bin/env node
-// ─── MEMO CLI Entry Point ────────────────────────────────────────────────────
+// ─── MEMO Tools CLI ────────────────────────────────────────────────────────
 //
-// Commands:
-//   memo validate       — Validate model against closure rules
-//   memo init           — Scaffold a new project
-//   memo pack           — Package the model as a KPAR archive
-//   memo export json    — Export model as JSON
-//   memo export dot     — Export model as Graphviz DOT
-//   memo ontology show  — Show resolved ontology summary
-//   memo ontology export— Export ontology as OWL/RDF or a SysAnd project
-//   memo check          — Check model compatibility (--sysml-compat)
-//   memo round-trip     — Predict round-trip conformance with external tools
+// Compile a model with the selected SysML compiler, validate it, and pack it.
+//   memo compile          — is this valid SysML (stage 1)
+//   memo validate         — the model against the rules, and completeness
+//   memo toolchain check  — the validator over files that are not a model
+//   memo pack             — package a model or package (a KPAR, or MEMO's own bundle)
+//   memo ship-library     — a package's compiled library, for the package to carry
+//
+// Creating a model, authoring, packaging, exporting, settings and the rest
+// are memo-architect's commands. The old names here fail loudly for one
+// release and name where each went.
 // ─────────────────────────────────────────────────────────────────────────────
 import { Command } from 'commander';
+import { memoVersion } from '../version.js';
 import { validateCommand } from '../commands/validate.js';
-import { initCommand, listExamplesCommand, listTemplatesCommand } from '../commands/init.js';
 import { packCommand } from '../commands/pack.js';
-import { exportJsonCommand, exportDotCommand } from '../commands/export.js';
-import { exportDhfCommand, dhfStatusCommand, dhfSnapshotCommand, dhfDiffCommand, dhfRedlineCommand, dhfReviewPacketCommand, } from '../commands/dhf.js';
-import { ontologyShowCommand, ontologyExportOwlCommand, ontologyExportSysandCommand, ontologyAddKindCommand, } from '../commands/ontology.js';
-import { importCsvCommand, importRelCsvCommand, importTemplateCommand, importDiffCommand } from '../commands/import.js';
-import { importEaCommand, importCameoCommand } from '../commands/import-ea.js';
-import { importSysandCommand } from '../commands/import-sysand.js';
-import { importKpar, inspectKpar } from '../commands/package.js';
-import { importOwlCommand } from '../commands/import-owl.js';
 import { sysandPublishCommand } from '../commands/sysand-publish.js';
-import { lockCommand } from '../commands/lock.js';
-import { installCommand } from '../commands/install.js';
-import { createPackageCommand } from '../commands/create-package.js';
-import { askCommand } from '../commands/ask.js';
-import { mcpCommand, mcpInitCommand } from '../commands/mcp.js';
-import { generateCommand } from '../commands/generate.js';
-import { dhfDraftCommand } from '../commands/dhf-draft.js';
-import { dhfLintCommand } from '../commands/dhf-lint.js';
-import { dhfInitCommand } from '../commands/dhf-init.js';
-import { dhfPreviewCommand } from '../commands/dhf-preview.js';
-import { standardsCheckCommand } from '../commands/standards.js';
-import { pluginListCommand, pluginCreateCommand, pluginRunCommand } from '../commands/plugin.js';
-import { reqNewCommand } from '../commands/req.js';
-import { checkCommand } from '../commands/check.js';
-import { roundTripCommand } from '../commands/roundtrip.js';
-import { rulesListCommand, rulesCheckCommand, rulesExplainCommand, rulesCoverageCommand } from '../commands/rules.js';
 import { inspectCommand } from '../commands/inspect.js';
-import { elementIdentitiesCommand, elementWriteCommand, } from '../commands/element.js';
-import { convertCommand } from '../commands/convert.js';
-import { configEffectiveCommand, toolchainProbeCommand } from '../commands/toolchain.js';
-import { conformanceBnfCommand, conformanceDiffXmiCommand, conformanceRulesCommand, conformanceRunCommand, } from '../commands/conformance.js';
+import { rulesExplainCommand, rulesListCommand } from '../commands/rules.js';
+import { standardsCheckCommand } from '../commands/standards.js';
+import { retiredCommand } from '../commands/retired.js';
+import { configEffectiveCommand, toolchainCheckCommand, toolchainProbeCommand, } from '../commands/toolchain.js';
 import { applyToolchainCliOptions } from '../toolchain/schema.js';
+import { compileCommand } from '../commands/compile.js';
+import { pinnedTarget } from '../commands/pinned-target.js';
+import { pruneCommand } from '../commands/prune.js';
+import { shipLibraryCommand } from '../commands/ship-library.js';
 import { defaultRegistry } from '../toolchain/default-registry.js';
+import chalk from 'chalk';
+import { Stage1RejectedError } from '../toolchain/project-model.js';
+import { ToolchainNotConfiguredError } from '../toolchain/effective.js';
+import { ProjectNamesUserSettingError } from '../toolchain/ownership.js';
+import { setCommandLineToolchain } from '../model/config-loader.js';
+import { toolchainOverridesFromCliOptions } from '../toolchain/schema.js';
 const program = new Command();
 /**
  * Add the generated `--toolchain.*` options to a command.
@@ -60,613 +46,176 @@ const withToolchainOptions = (command) => applyToolchainCliOptions(command, defa
 program
     .name('memo')
     .description('MEMO — Model-Based Systems Engineering for Medical Devices')
-    .version('0.6.7');
+    .version(memoVersion());
 withToolchainOptions(program
-    .command('validate')
-    .description('Validate the model against closure rules and show completeness')
-    .argument('[dir]', 'Project directory', '.')
-    .option('--format <format>', 'Output format: text, junit, json', 'text')
-    .option('-o, --output <file>', 'Write output to file instead of stdout')).action(async (dir, opts) => {
-    await validateCommand(dir, { ...opts, format: opts.format, output: opts.output });
-});
-program
-    .command('inspect <id>')
-    .description('Inspect a model element or relationship')
-    .option('--provenance', 'Show declaration and classifier provenance only')
-    .option('-d, --dir <dir>', 'Project directory', '.')
-    .action(async (id, options) => {
-    await inspectCommand(id, options);
-});
-// ─── memo element ───────────────────────────────────────────────────────────
-//
-// The CLI surface for authoring write-back, so the operation Architect calls is
-// scriptable too (§1.2.2 rule 2). Same implementation, same lowering provider.
-const elementCmd = program
-    .command('element')
-    .description('Author project source through the toolchain');
-withToolchainOptions(elementCmd
-    .command('identities')
-    .description('Print the IR identity to quote when writing to each element')
-    .argument('[dir]', 'Project directory', '.')
-    .option('--id <id>', 'Restrict output to one element')
-    .option('--format <format>', 'Output format: text, json', 'text')).action(async (dir, opts) => {
-    await elementIdentitiesCommand(dir, opts);
-});
-withToolchainOptions(elementCmd
-    .command('write')
-    .description('Write one element back to source and recompile')
-    .argument('[dir]', 'Project directory', '.')
-    .option('--id <id>', 'Element ID to create or update')
-    .option('--name <name>', 'Display name')
-    .option('--kind <kind>', 'Ontology kind')
-    .option('--construct <construct>', 'SysML construct, e.g. part, action, requirement')
-    .option('--layer <layer>', 'MEMO layer')
-    .option('--doc <text>', 'Documentation body')
-    .option('--attribute <key=value...>', 'Attribute assignment, repeatable')
-    .option('--file <path>', 'Project-relative source file to write into')
-    .option('--ir-identity <identity>', 'IR identity of the declaration being updated')
-    .option('--renamed-from <id>', 'Previous element ID, when this write renames the declaration')
-    .option('--by-id', 'Resolve the identity from --id instead of quoting one (cannot detect a stale view)')
-    .option('--request <file>', 'JSON file holding the whole write request')
-    .option('--format <format>', 'Output format: text, json', 'text')).action(async (dir, opts) => {
-    await elementWriteCommand(dir, opts);
-});
-program
-    .command('init')
-    .description('Scaffold a new MEMO project')
-    .argument('[name]', 'Project directory (omit or "." to initialize the current directory)')
-    .option('-t, --template <id>', 'Create from an ontology template')
-    .option('--ontology <package>', 'Logical ontology package to use (defaults from the content manifest)')
-    .option('--example <id>', 'Create from an example project (e.g. gpca)')
-    .option('--list', 'List installed ontology templates and examples')
-    .option('--no-install', 'Create the project without running npm install')
-    .action(async (name, options) => {
-    await initCommand(name, options);
+    .command('ship-library')
+    .description("Export a package's library set with the selected compiler, for the package to carry (stage1/)")
+    .argument('[dir]', 'Package directory whose manifest offers the library roots', '.')
+    .option('--out <dir>', 'Directory to write the shipped files to (default: <dir>/stage1)')).action(async (dir, opts) => {
+    await shipLibraryCommand(dir, opts);
 });
-program
-    .command('convert')
-    .description('Restructure a project into the native catalog layout (dry run unless --write)')
-    .argument('[dir]', 'Project directory', '.')
-    .option('--write', 'Apply the plan. Without it the command only reports what would change.')
-    .option('--diff', 'Include per-file content hunks in the report')
-    .option('--json', 'Emit the plan as JSON')
-    .option('--normalize-names', 'Also rename in-place packages whose names do not mirror their location')
-    .action(async (dir, options) => {
-    await convertCommand(dir, options);
+withToolchainOptions(program
+    .command('compile')
+    .description('Check the model is valid SysML with the selected compiler (stage 1); no MEMO rules')
+    .argument('[dir]', 'Model directory', '.')
+    .option('--at <ref>', 'Compile the model as it was at this commit, tag or branch (a cached worktree under .memo/pinned)')
+    .option('--release <record>', 'Compile the SoS version a release record names: the version\'s commit with each system from its own release\'s commit')
+    .option('--strict-ontology', 'With --at or --release: refuse when the commit was made with another ontology version than this run would use')
+    .option('--force', 'Compile even when the stage 1 output in .memo/stage1 is fresh')
+    .option('--out <file>', 'Write the compiled SysML v2 model (API JSON, diagnostics, element index) to this file')
+    .option('--inspect <id>', 'Instead of compiling, show a model element or relationship')
+    .option('--provenance', 'With --inspect: only the declaration and classifier provenance')
+    .option('--probe', 'Instead of compiling, show which provider fills each role, its executable and version')
+    .option('--effective', 'Instead of compiling, print the settings that are in effect, after flags and the environment')
+    .option('--format <format>', 'With --probe or --effective: text, json, yaml', undefined)).action(async (dir, opts) => {
+    // The read-only reports are flags of compile and validate, not commands of their own.
+    if (opts.inspect)
+        return inspectCommand(String(opts.inspect), { provenance: opts.provenance === true, dir });
+    if (opts.probe)
+        return toolchainProbeCommand(dir, { ...opts, format: opts.format });
+    if (opts.effective)
+        return configEffectiveCommand(dir, { ...opts, format: opts.format ?? 'yaml' });
+    const pinned = await pinnedTarget(dir, opts);
+    if (pinned)
+        console.error(chalk.gray(`(${pinned.label})`));
+    await compileCommand(pinned ? pinned.dir : dir, pinned ? { ...opts, at: undefined, release: undefined } : opts);
 });
-program
-    .command('examples')
-    .description('List installed worked examples and the IDs accepted by memo init --example')
-    .action(() => listExamplesCommand());
-const packageCmd = program.command('package').description('Inspect and import interoperable KPAR libraries');
-packageCmd.command('inspect').argument('<archive>').action((archive) => console.log(JSON.stringify(inspectKpar(archive), null, 2)));
-packageCmd.command('import').argument('<archive>').option('-C, --project <dir>', 'Project directory', '.').action((archive, options) => console.log(JSON.stringify(importKpar(options.project, archive), null, 2)));
-program
-    .command('templates')
-    .description('List installed project templates and the IDs accepted by memo init --template')
-    .action(() => listTemplatesCommand());
 withToolchainOptions(program
     .command('pack')
-    .description('Package the model as a MEMO bundle (not an interoperable KPAR)')
-    .option('-o, --output <file>', 'Output .memo-bundle path')).action(async (options) => {
+    .description('Package the model or package you are in, with toolchain.packager: a KPAR (sysand) or MEMO\'s own bundle (internal)')
+    .option('-o, --output <file>', 'Output file (default: <name>-<version>.kpar for sysand, <name>.memo-bundle otherwise)')).action(async (options) => {
     await packCommand({ ...options, output: options.output });
 });
-// ─── memo toolchain ─────────────────────────────────────────────────────────
-const toolchainCmd = program
-    .command('toolchain')
-    .description('Inspect the configured SysML toolchain');
-withToolchainOptions(toolchainCmd
-    .command('probe')
-    .description('Resolve each role to a provider and report its executable and version')
-    .argument('[dir]', 'Project directory', '.')
-    .option('--format <format>', 'Output format: text, json, yaml', 'text')).action(async (dir, opts) => {
-    await toolchainProbeCommand(dir, { ...opts, format: opts.format });
-});
-// ─── memo conformance ───────────────────────────────────────────────────────
-//
-// Its own command, reached no other way. Nothing in `validate`, `dev`, `build`
-// or Architect's refresh calls into `conformance/`: a sweep grades MEMO against
-// the OMG's published files, which is a question about MEMO and not about the
-// project the user is working on.
-const conformanceCmd = program
-    .command('conformance')
-    .description('Run the toolchain against the pinned SysML v2 Release corpus');
-withToolchainOptions(conformanceCmd
-    .command('run')
-    .description('Validate and lower the corpus; report diagnostic counts by domain')
-    .argument('[dir]', 'Project whose toolchain settings select the providers', '.')
-    .option('--corpus <dir>', 'Corpus directory (defaults to the vendored one)')
-    .option('--unit <id...>', 'Corpus units to run; a prefix selects a group')
-    .option('--format <format>', 'Output format: text, json', 'text')
-    .option('-o, --output <file>', 'Write the report to a file instead of stdout')
-    .option('--verify <scope>', 'Checksum scope: sources, full, skipped', 'sources')
-    .option('--baseline [file]', 'Compare against a frozen baseline and fail on any change')
-    .option('--update-baseline', 'Re-freeze the baseline from this run')).action(async (dir, opts) => {
-    await conformanceRunCommand(dir, opts);
-});
-withToolchainOptions(conformanceCmd
-    .command('diff-xmi')
-    .description("Compare MEMO's computed semantics against the Release xmi.implied files")
-    .argument('[dir]', 'Project whose toolchain settings select the lowering provider', '.')
-    .option('--corpus <dir>', 'Corpus directory (defaults to the vendored one)')
-    .option('--library <path...>', 'Library sources to compare, e.g. Parts.sysml')
-    .option('--format <format>', 'Output format: text, json', 'text')
-    .option('-o, --output <file>', 'Write the report to a file instead of stdout')
-    .option('--verify <scope>', 'Checksum scope: sources, skipped', 'sources')
-    .option('--baseline [file]', 'Compare against a frozen baseline and fail on any change')
-    .option('--update-baseline', 'Re-freeze the baseline from this run')).action(async (dir, opts) => {
-    await conformanceDiffXmiCommand(dir, opts);
-});
-conformanceCmd
-    .command('bnf')
-    .description("Score the grammar's rule coverage against the normative textual BNF")
-    .argument('[dir]', 'Unused; accepted so every conformance subcommand takes the same shape', '.')
-    .option('--corpus <dir>', 'Corpus directory (defaults to the vendored one)')
-    .option('--grammar <file>', "Grammar to score (defaults to MEMO's)")
-    .option('--missing', 'List the syntactic productions with no rule')
-    .option('--format <format>', 'Output format: text, json', 'text')
-    .option('-o, --output <file>', 'Write the report to a file instead of stdout')
-    .option('--baseline [file]', 'Compare against a frozen baseline and fail on any change')
-    .option('--update-baseline', 'Re-freeze the baseline from this run')
-    .action(async (dir, opts) => {
-    await conformanceBnfCommand(dir, opts);
-});
-conformanceCmd
-    .command('rules')
-    .description("Score MEMO's well-formedness constraints against Syside's published rule codes")
-    .argument('[dir]', 'Unused; accepted so every conformance subcommand takes the same shape', '.')
-    .option('--missing', 'List the codes with no implementation, and why')
-    .option('--format <format>', 'Output format: text, json', 'text')
-    .option('-o, --output <file>', 'Write the report to a file instead of stdout')
-    .action(async (dir, opts) => {
-    await conformanceRulesCommand(dir, opts);
-});
-// ─── memo config ────────────────────────────────────────────────────────────
-const configCmd = program
-    .command('config')
-    .description('Inspect resolved application settings');
-withToolchainOptions(configCmd
-    .command('effective')
-    .description('Print settings after flags, the deprecated alias, and defaults are applied')
-    .argument('[dir]', 'Project directory', '.')
-    .option('--format <format>', 'Output format: yaml, json', 'yaml')).action(async (dir, opts) => {
-    await configEffectiveCommand(dir, { ...opts, format: opts.format });
-});
-const exportCmd = program
-    .command('export')
-    .description('Export model to various formats');
-exportCmd
-    .command('json')
-    .description('Export full model as JSON')
-    .option('-o, --output <file>', 'Output file path', 'memo-model.json')
-    .option('--no-pretty', 'Minified JSON output')
-    .action(async (options) => {
-    await exportJsonCommand(options);
-});
-exportCmd
-    .command('dhf')
-    .description('Export DHF documents (HTML, Markdown, DOCX)')
-    .option('-o, --output <dir>', 'Output directory', 'dhf-output')
-    .option('-t, --target <id>', 'Target document ID (e.g., rmp, har, fmea)')
-    .option('-f, --format <fmt>', 'Output format: html, md, docx', 'html')
-    .option('-g, --group <group>', 'Document group: risk, design, verification, compliance, all')
-    .action(async (options) => {
-    await exportDhfCommand(options);
-});
-exportCmd
-    .command('dot')
-    .description('Export model as Graphviz DOT format')
-    .option('-o, --output <file>', 'Output file path', 'memo-model.dot')
-    .option('--viewpoint <id>', 'Filter by viewpoint ID')
-    .action(async (options) => {
-    await exportDotCommand(options);
-});
-program
-    .command('create-package')
-    .description('Scaffold a new MEMO package (ontology, profile, or library)')
-    .argument('<name>', 'Package name (e.g., @myorg/cardiac-ontology)')
-    .option('-t, --type <type>', 'Package type: ontology, profile, library, device', 'ontology')
-    .option('-e, --extends <package>', 'Package to extend (auto-set for profiles)')
-    .option('-d, --description <desc>', 'Package description')
-    .option('--author <author>', 'Package author')
-    .option('--license <license>', 'License', 'Apache-2.0')
-    .option('-o, --output <dir>', 'Output base directory', '.')
-    .action(async (name, options) => {
-    await createPackageCommand(name, options);
-});
-program
-    .command('install')
-    .description('Install locked MEMO content, or add a package from git, npm, or a local path')
-    .argument('[source]', 'Optional package source: git URL, npm package name, or local path')
-    .option('--mode <mode>', 'Force install mode: git, npm, or local')
-    .action(async (source, options) => {
-    await installCommand(source, options);
-});
-program
-    .command('lock')
-    .description('Regenerate memo.lock.yaml from the current ontology')
-    .action(async () => {
-    await lockCommand();
-});
-// ─── memo ontology ──────────────────────────────────────────────────────────
-const ontologyCmd = program
-    .command('ontology')
-    .description('Ontology management commands');
-ontologyCmd
-    .command('show')
-    .description('Show resolved ontology summary (kinds, relationships, rules)')
-    .action(async () => {
-    await ontologyShowCommand();
-});
-const ontologyExportCmd = ontologyCmd
-    .command('export')
-    .description('Export ontology to standard formats');
-ontologyExportCmd
-    .command('owl')
-    .description('Export ontology as OWL/RDF (Turtle)')
-    .option('-o, --output <file>', 'Output file path')
-    .option('--namespace <uri>', 'Ontology namespace URI', 'https://sysand.dev/ontology/memo#')
-    .action(async (options) => {
-    await ontologyExportOwlCommand({ ...options, format: 'turtle' });
-});
-ontologyExportCmd
-    .command('xml')
-    .description('Export ontology as OWL/RDF (XML)')
-    .option('-o, --output <file>', 'Output file path')
-    .option('--namespace <uri>', 'Ontology namespace URI', 'https://sysand.dev/ontology/memo#')
-    .action(async (options) => {
-    await ontologyExportOwlCommand({ ...options, format: 'xml' });
-});
-ontologyExportCmd
-    .command('sysand')
-    .description('Export ontology dependency stack as a SysAnd project')
-    .option('-o, --output <dir>', 'Output directory path')
-    .action(async (options) => {
-    await ontologyExportSysandCommand(options);
-});
-ontologyCmd
-    .command('add-kind <name>')
-    .description('Write a new SysML kind definition file into the local ontology folder')
-    .requiredOption('-l, --layer <layer>', 'Ontology layer path (e.g. requirements, architecture/risk)')
-    .option('-o, --output <dir>', 'Override output directory (default: ontology/<layer>)')
-    .action((name, options) => {
-    ontologyAddKindCommand(name, options);
-});
-// ─── memo import ──────────────────────────────────────────────────────────
-const importCmd = program
-    .command('import')
-    .description('Import models from CSV, Sparx EA, Cameo, SysAnd, or OWL/JSON-LD');
-importCmd
-    .command('csv')
-    .description('Import elements from a CSV file (generates .sysml)')
-    .argument('<file>', 'CSV file path')
-    .option('-o, --output <file>', 'Output .sysml file path')
-    .option('--package <name>', 'SysML package name')
-    .option('--dry-run', 'Preview generated SysML without writing')
-    .action(async (file, options) => {
-    await importCsvCommand(file, options);
-});
-importCmd
-    .command('csv-rel')
-    .description('Import relationships from a CSV file (generates .sysml)')
-    .argument('<file>', 'CSV file path')
-    .option('-o, --output <file>', 'Output .sysml file path')
-    .option('--package <name>', 'SysML package name')
-    .option('--dry-run', 'Preview generated SysML without writing')
-    .action(async (file, options) => {
-    await importRelCsvCommand(file, options);
-});
-importCmd
-    .command('template')
-    .description('Generate a template CSV based on the ontology (elements or relationships)')
-    .argument('<type>', 'Template type: "elements" or "relationships"')
-    .option('-o, --output <file>', 'Output CSV file path')
-    .action(async (type, options) => {
-    await importTemplateCommand(type, options);
-});
-importCmd
-    .command('diff')
-    .description('Preview what a CSV import would change without modifying the model')
-    .argument('<file>', 'CSV file path')
-    .option('--detect-removals', 'Also report elements in the model missing from the CSV')
-    .action(async (file, options) => {
-    await importDiffCommand(file, options);
-});
-importCmd
-    .command('ea')
-    .description('Import from Sparx EA JSON export (.json)')
-    .argument('<file>', 'EA JSON export file')
-    .option('-o, --output <file>', 'Output .sysml file path')
-    .option('--package <name>', 'SysML package name')
-    .option('--dry-run', 'Preview generated SysML without writing')
-    .action(async (file, options) => {
-    await importEaCommand(file, options);
-});
-importCmd
-    .command('cameo')
-    .description('Import from MagicDraw/Cameo XMI or JSON (.xml/.json)')
-    .argument('<file>', 'Cameo XMI/XML or JSON file')
-    .option('-o, --output <file>', 'Output .sysml file path')
-    .option('--package <name>', 'SysML package name')
-    .option('--dry-run', 'Preview generated SysML without writing')
-    .action(async (file, options) => {
-    await importCameoCommand(file, options);
-});
-importCmd
-    .command('sysand')
-    .description('Import a SysAnd project directory (.project.json + SysML files)')
-    .argument('<dir>', 'SysAnd project directory')
-    .option('--verify', 'Verify round-trip against current ontology')
-    .action(async (dir, options) => {
-    await importSysandCommand(dir, options);
-});
-importCmd
-    .command('owl')
-    .description('Import an OWL/Turtle or JSON-LD ontology')
-    .argument('<file>', 'OWL/Turtle (.ttl/.owl) or JSON-LD (.jsonld/.json) file')
-    .option('-o, --output <file>', 'Output .sysml file path')
-    .option('--package <name>', 'SysML package name')
-    .option('--package-dir <dir>', 'Create full ontology package directory')
-    .option('--dry-run', 'Preview generated SysML without writing')
-    .action(async (file, options) => {
-    await importOwlCommand(file, options);
-});
-// ─── memo ask ────────────────────────────────────────────────────────────────
-program
-    .command('ask')
-    .description('Ask a question about the model using LLM')
-    .argument('<question>', 'Natural language question about the model')
-    .option('--layer <layer>', 'Filter context to a specific layer')
-    .option('--kind <kind>', 'Filter context to a specific kind')
-    .action(async (question, options) => {
-    await askCommand(question, options);
+withToolchainOptions(program
+    .command('publish')
+    .description('Dry run of publishing the package or model you are in: stages what `memo pack` stages and reports the artifact; writes and uploads nothing')
+    .option('-p, --package <name>', 'Check that this is the package named (by name or directory)')).action(async (options) => {
+    await sysandPublishCommand({ ...options, dryRun: true });
 });
-// ─── memo mcp ────────────────────────────────────────────────────────────────
-// `init` is a positional argument rather than a subcommand: commander binds an
-// option declared on both a command and its subcommand to the parent, so
-// `memo mcp init --project X` would silently lose --project.
-program
-    .command('mcp')
-    .description('Serve the model to AI coding tools over the Model Context Protocol')
-    .argument('[action]', 'Omit to serve; "init" to register the server with Cursor')
-    .option('--project <dir>', 'Project directory (defaults to the current one)')
-    .option('--write', 'Enable the model-editing tools (read-only by default)')
-    .option('--no-rules', 'With "init", skip writing .cursor/rules/memo.mdc')
-    .action(async (action, options) => {
-    if (action === 'init') {
-        await mcpInitCommand({
-            project: options.project,
-            write: options.write,
-            noRules: options.rules === false,
-        });
+withToolchainOptions(program
+    .command('validate')
+    .description('Validate the model against closure rules and show completeness')
+    .argument('[dir]', 'Model directory', '.')
+    .option('--format <format>', 'Output format: text, junit, json', 'text')
+    .option('-o, --output <file>', 'Write output to file instead of stdout')
+    .option('--no-server', 'Compile here even when `memo dev` is running for the model')
+    .option('--at <ref>', 'Validate the model as it was at this commit, tag or branch; writes nothing into the project')
+    .option('--release <record>', 'Validate the SoS version a release record names; writes nothing into the project')
+    .option('--strict-ontology', 'With --at or --release: refuse when the commit was made with another ontology version than this run would use')
+    .option('--workspace <name>', 'Validate one workspace: a System or the SystemOfSystems definition. Rules run on its elements over the whole model')
+    .option('--rules', 'Instead of validating, list the consistency rules in effect (--format text or json)')
+    .option('--rules-domain <domain>', 'With --rules: modelling, medicalDevice, organisation')
+    .option('--rules-obligation <obligation>', 'With --rules: required, recommended, bestPractice')
+    .option('--rules-category <category>', 'With --rules: invariant, assurance, methodology')
+    .option('--explain-rule <id>', 'Instead of validating, show one rule in detail (e.g. CR-MED-001)')
+    .option('--standards', 'Instead of validating, report clause coverage: required, claimed, evidenced')
+    .option('--standard <designation>', 'With --standards: only this standard (substring of the designation)')
+    .option('--regime <regime...>', 'With --standards: scope to these regimes, overriding what the model declares')
+    .option('--gaps-only', 'With --standards: only clauses nothing claims')).action(async (dir, opts) => {
+    // The read-only reports are flags of compile and validate, not commands of their own.
+    const reportFormat = opts.format === 'json' ? 'json' : 'text';
+    if (opts.format === 'junit' && (opts.rules || opts.explainRule || opts.standards)) {
+        console.error(chalk.red('✖ the rule and standards reports are text or json, not junit.'));
+        process.exitCode = 1;
         return;
     }
-    if (action) {
-        console.error(`Unknown action "${action}". Use \`memo mcp\` to serve, or \`memo mcp init\`.`);
-        process.exit(1);
+    if (opts.rules)
+        return rulesListCommand(dir, { format: reportFormat, category: opts.rulesCategory, domain: opts.rulesDomain, obligation: opts.rulesObligation });
+    if (opts.explainRule)
+        return rulesExplainCommand(String(opts.explainRule), dir, { format: reportFormat });
+    if (opts.standards) {
+        return standardsCheckCommand({
+            standard: opts.standard, regime: opts.regime,
+            gapsOnly: opts.gapsOnly === true, json: reportFormat === 'json',
+        });
     }
-    // Runs until the client closes stdin; stdout is reserved for JSON-RPC.
-    await mcpCommand({ project: options.project, write: options.write, version: program.version() });
-});
-// ─── memo generate ───────────────────────────────────────────────────────────
-program
-    .command('generate')
-    .description('Generate SysML from a natural language description using LLM')
-    .argument('<description>', 'Natural language description of what to generate')
-    .option('-o, --output <file>', 'Output .sysml file path (preview if omitted)')
-    .option('--dry-run', 'Preview generated SysML without writing')
-    .action(async (description, options) => {
-    await generateCommand(description, options);
-});
-// ─── memo req ────────────────────────────────────────────────────────────────
-const reqCmd = program
-    .command('req')
-    .description('Requirement authoring helpers');
-reqCmd
-    .command('new')
-    .description('Generate a requirement stub from an EARS template')
-    .requiredOption('-t, --template <template>', 'Template: ubi, event, state, opt, unwanted')
-    .option('-o, --output <file>', 'Write stub to file (stdout if omitted)')
-    .option('--id <reqId>', 'Requirement ID', 'REQ-001')
-    .option('--title <title>', 'Requirement title', 'New Requirement')
-    .action(async (options) => {
-    await reqNewCommand({
-        template: options.template,
-        output: options.output,
-        id: options.id,
-        title: options.title,
+    const pinned = await pinnedTarget(dir, opts);
+    if (pinned)
+        console.error(chalk.gray(`(${pinned.label})`));
+    await validateCommand(pinned ? pinned.dir : dir, {
+        ...opts, at: undefined, release: undefined, readOnly: pinned ? true : undefined,
+        format: opts.format, output: opts.output,
     });
 });
-// ─── memo plugin ─────────────────────────────────────────────────────────────
-const pluginCmd = program
-    .command('plugin')
-    .description('Plugin management commands');
-pluginCmd
-    .command('list')
-    .description('List configured plugins')
-    .action(async () => {
-    await pluginListCommand();
-});
-pluginCmd
-    .command('create')
-    .description('Scaffold a new plugin')
-    .argument('<name>', 'Plugin name')
-    .option('-t, --type <type>', 'Plugin type: export, analysis, validation, generator', 'export')
-    .option('-d, --description <desc>', 'Plugin description')
-    .option('-o, --output <dir>', 'Output directory')
-    .action(async (name, options) => {
-    await pluginCreateCommand(name, options);
-});
-pluginCmd
-    .command('run')
-    .description('Run a generator or analysis plugin')
-    .argument('<id>', 'Plugin ID')
-    .option('--json', 'Output results as JSON')
-    .action(async (id, options) => {
-    await pluginRunCommand(id, options);
-});
-// ─── memo dhf ────────────────────────────────────────────────────────────────
-const dhfCmd = program
-    .command('dhf')
-    .description('Design History File workbench');
-dhfCmd
-    .command('init')
-    .description('Scaffold DHF document set for your medical device project (interactive wizard)')
-    .option('-d, --dir <path>', 'Project directory', '.')
-    .action(async (options) => {
-    await dhfInitCommand({ projectDir: options.dir });
-});
-dhfCmd
-    .command('preview')
-    .description('Start local DHF preview server with live reload')
-    .option('-p, --port <port>', 'Server port', '3001')
-    .action(async (options) => {
-    await dhfPreviewCommand({ port: parseInt(options.port, 10) });
-});
-dhfCmd
-    .command('lint')
-    .description('Validate DHF templates against the ontology they query')
-    .option('-f, --filter <prefix>', 'Only lint templates whose id starts with this prefix')
-    .option('--structural-only', 'Skip ontology resolution; check frontmatter and query syntax only')
-    .option('--json', 'Emit JSON for CI')
-    .action(async (options) => {
-    await dhfLintCommand(options);
-});
-dhfCmd
-    .command('status')
-    .description('Show DHF document readiness status')
-    .option('-v, --verbose', 'Show section-level detail')
-    .option('-t, --target <id>', 'Target document ID')
-    .action(async (options) => {
-    await dhfStatusCommand(options);
-});
-dhfCmd
-    .command('snapshot')
-    .description('Create a snapshot of current DHF document state')
-    .option('-t, --target <id>', 'Target document ID (default: all)')
-    .option('-l, --label <label>', 'Snapshot label')
-    .action(async (options) => {
-    await dhfSnapshotCommand(options);
-});
-dhfCmd
-    .command('diff')
-    .description('Compare current state against latest snapshot')
-    .requiredOption('-t, --target <id>', 'Target document ID')
-    .action(async (options) => {
-    await dhfDiffCommand(options);
-});
-dhfCmd
-    .command('redline')
-    .description('Generate redline document showing changes from last snapshot')
-    .requiredOption('-t, --target <id>', 'Target document ID')
-    .option('-f, --format <fmt>', 'Output format: html, md, docx', 'html')
-    .option('-o, --output <file>', 'Output file path')
-    .action(async (options) => {
-    await dhfRedlineCommand(options);
-});
-dhfCmd
-    .command('draft')
-    .description('Use LLM to draft content for gap sections in a DHF document')
-    .requiredOption('-t, --target <id>', 'Target document ID (e.g., rmp, har, fmea)')
-    .option('-s, --section <id>', 'Draft only a specific section')
-    .option('-f, --format <fmt>', 'Output format: html, md, docx', 'html')
-    .option('-o, --output <dir>', 'Output directory', 'dhf-drafts')
-    .action(async (options) => {
-    await dhfDraftCommand(options);
-});
-dhfCmd
-    .command('review-packet')
-    .description('Generate a complete review packet of all DHF documents')
-    .option('-f, --format <fmt>', 'Output format: html, md, docx', 'html')
-    .option('-o, --output <dir>', 'Output directory')
-    .action(async (options) => {
-    await dhfReviewPacketCommand(options);
-});
-// ─── memo standards ─────────────────────────────────────────────────────────
-const standardsCmd = program
-    .command('standards')
-    .description('Regulatory standards conformance');
-standardsCmd
+// ─── memo toolchain ─────────────────────────────────────────────────────────
+const toolchainCmd = program
+    .command('toolchain')
+    .description('Inspect the configured SysML toolchain');
+withToolchainOptions(toolchainCmd
     .command('check')
-    .description('Report clause coverage: required, claimed, and evidenced')
-    .option('-s, --standard <designation>', 'Only this standard (substring of the designation)')
-    .option('-r, --regime <regime...>', 'Scope to these regimes, overriding the project declaration')
-    .option('--gaps-only', 'Show only clauses nothing claims')
-    .option('--json', 'Emit JSON for CI and for the Architect')
-    .action(async (options) => {
-    await standardsCheckCommand(options);
-});
-// ─── memo sysand ────────────────────────────────────────────────────────────
-const sysandCmd = program
-    .command('sysand')
-    .description('SysAnd tool interop commands');
-sysandCmd
-    .command('publish')
-    .description('Validate and package ontology for SysAnd registry publication')
-    .option('--dry-run', 'Validate without writing artifacts (default)')
-    .option('-p, --package <name>', 'Publish a specific package from the config chain')
-    .action(async (options) => {
-    await sysandPublishCommand({ ...options, dryRun: options.dryRun ?? true });
-});
-// ─── memo check ─────────────────────────────────────────────────────────────
+    .description('Run the selected validator over these SysML paths, less the listed exceptions')
+    .argument('[paths...]', 'Files or directories, relative to the model directory', [])
+    .option('-p, --project <dir>', 'Model directory: settings, exceptions and relative paths', '.')
+    .option('--exceptions <file>', 'Exceptions register, relative to the model (default validator-exceptions.json)')).action(async (paths, opts) => {
+    await toolchainCheckCommand(paths, opts);
+});
+retiredCommand(toolchainCmd, 'probe', 'memo compile --probe');
+// ─── Retired: conformance ───────────────────────────────────────────────────
+retiredCommand(program, 'conformance', {
+    reason: 'it graded MEMO\'s own SysML compiler against the OMG corpus, and that compiler is gone. '
+        + 'The selected compiler is the authority on validity: `memo compile`.',
+});
+// ─── Retired: check, round-trip ──────────────────────────────────────────────
+// Heuristic guesses at what external SysML tools accept, from before the
+// selected compiler was the authority on validity; `memo compile` asks it.
+retiredCommand(program, 'check', 'memo compile');
+retiredCommand(program, 'round-trip', 'memo compile');
+// ─── Moved to memo-architect ───────────────────────────────────────────────
+// One way of doing a thing: these are `memo-architect <command>` now. The old
+// names stay for one release, hidden, and fail naming the replacement.
+retiredCommand(program, 'inspect', 'memo compile --inspect <id>');
+retiredCommand(program, 'element', 'memo-architect element');
+retiredCommand(program, 'init', 'memo-architect init');
+retiredCommand(program, 'convert', 'memo-architect convert');
+retiredCommand(program, 'package', 'memo-architect import kpar [--inspect] <archive>');
+retiredCommand(program, 'config', 'memo compile --effective (what is in effect); memo-architect config (to change it)');
+retiredCommand(program, 'export', 'memo-architect export');
+retiredCommand(program, 'create-package', 'memo-architect new package');
+retiredCommand(program, 'install', 'memo-architect install');
 program
-    .command('check')
-    .description('Check model compatibility with SysML v2 tools')
-    .argument('[dir]', 'Project directory', '.')
-    .option('--sysml-compat', 'Run SysML v2 standard compatibility check')
-    .option('--format <format>', 'Output format: text, json', 'text')
-    .option('-o, --output <file>', 'Write report to file instead of stdout')
+    .command('prune')
+    .description('Remove the pinned worktrees (.memo/pinned) and assemblies (.memo/assembled) not used lately; both are rebuilt on demand')
+    .argument('[dir]', 'Model directory', '.')
+    .option('--keep <n>', 'How many of each to keep, most recently used first', '5')
+    .option('--dry-run', 'List what would be removed and remove nothing')
     .action(async (dir, opts) => {
-    await checkCommand(dir, { sysmlCompat: opts.sysmlCompat, format: opts.format, output: opts.output });
-});
-// ─── memo round-trip ────────────────────────────────────────────────────────
-program
-    .command('round-trip')
-    .description('Predict round-trip conformance with external SysML tools')
-    .argument('[dir]', 'Project directory', '.')
-    .option('--tool <tool>', 'Target tool: syson, syside, cameo', 'syson')
-    .option('--format <format>', 'Output format: text, json', 'text')
-    .option('-o, --output <file>', 'Write report to file instead of stdout')
-    .action(async (dir, opts) => {
-    await roundTripCommand(dir, { tool: opts.tool, format: opts.format, output: opts.output });
-});
-// ─── memo rules ────────────────────────────────────────────────────────────
-const rulesCmd = program
-    .command('rules')
-    .description('Consistency rule management');
-rulesCmd
-    .command('list')
-    .description('List all consistency rules')
-    .argument('[dir]', 'Project directory', '.')
-    .option('--format <format>', 'Output format: text, json', 'text')
-    .option('--category <category>', 'Filter by category: closure, coverage, lifecycle, crossLayer, quantitative')
-    .action(async (dir, opts) => {
-    await rulesListCommand(dir, { format: opts.format, category: opts.category });
-});
-rulesCmd
-    .command('check')
-    .description('Evaluate rules against the current model')
-    .argument('[dir]', 'Project directory', '.')
-    .option('--format <format>', 'Output format: text, json', 'text')
-    .action(async (dir, opts) => {
-    await rulesCheckCommand(dir, { format: opts.format });
-});
-rulesCmd
-    .command('explain')
-    .description('Show detailed info for a specific rule')
-    .argument('<ruleId>', 'Rule ID (e.g., CR-MED-001)')
-    .argument('[dir]', 'Project directory', '.')
-    .option('--format <format>', 'Output format: text, json', 'text')
-    .action(async (ruleId, dir, opts) => {
-    await rulesExplainCommand(ruleId, dir, { format: opts.format });
-});
-rulesCmd
-    .command('coverage')
-    .description('Show coverage rules grouped by regulatory standard')
-    .argument('[dir]', 'Project directory', '.')
-    .option('--format <format>', 'Output format: text, json', 'text')
-    .action(async (dir, opts) => {
-    await rulesCoverageCommand(dir, { format: opts.format });
+    await pruneCommand(dir, opts);
+});
+retiredCommand(program, 'lock', 'memo-architect lock');
+retiredCommand(program, 'ontology', 'memo-architect ontology');
+retiredCommand(program, 'import', 'memo-architect import');
+retiredCommand(program, 'ask', 'memo-architect ask');
+retiredCommand(program, 'mcp', 'memo-architect mcp');
+retiredCommand(program, 'generate', 'memo-architect generate');
+retiredCommand(program, 'req', 'memo-architect new requirement --pattern <pattern>');
+retiredCommand(program, 'plugin', 'memo-architect plugin');
+retiredCommand(program, 'dhf', 'memo-architect dhf');
+retiredCommand(program, 'standards', 'memo validate --standards');
+retiredCommand(program, 'sysand', 'memo publish');
+retiredCommand(program, 'rules', 'memo validate --rules, --explain-rule <id> (to change them: memo-architect new rule, rules tailor|tailoring)');
+retiredCommand(program, 'examples', 'memo-architect init --list');
+retiredCommand(program, 'templates', 'memo-architect init --list');
+// Every command takes the `--toolchain.*` flags, and the running command's
+// flags apply to whatever settings it loads (model/config-loader.ts).
+const allCommands = (command) => [command, ...command.commands.flatMap(allCommands)];
+for (const command of allCommands(program)) {
+    if (command.commands.length > 0 || command === program)
+        continue;
+    if (!command.options.some(option => option.attributeName() === 'toolchain.compiler'))
+        withToolchainOptions(command);
+}
+program.hook('preAction', (_program, action) => {
+    setCommandLineToolchain(toolchainOverridesFromCliOptions(action.opts(), defaultRegistry));
+});
+// A stage 1 that rejects the source is a verdict on the model, not a crash:
+// every command that loads one reports its diagnostics and fails, as
+// `memo validate` does. Anything else is still a crash, with its stack.
+program.parseAsync().catch((error) => {
+    // So is a project whose settings name no compiler: MEMO chooses none.
+    if (error instanceof Stage1RejectedError || error instanceof ToolchainNotConfiguredError || error instanceof ProjectNamesUserSettingError) {
+        console.error(chalk.red(`\n❌ ${error.message}\n`));
+        process.exit(1);
+    }
+    throw error;
 });
-program.parse();
 //# sourceMappingURL=memo.js.map