@memoarchitect/tools 0.13.0 → 0.15.0

package/packages/tools/lib/commands/dev.js

@@ -11,20 +11,42 @@ import { existsSync, readFileSync } from 'node:fs';
 import { createHash } from 'node:crypto';
 import { execSync } from 'node:child_process';
 import chalk from 'chalk';
-import { IncrementalProjectParser, buildMemoModel, modelToDTO, lowerAstToSysmlIr, irIdentityTable, loadOntologyRegistries, getPackageMetadata, loadMethodologyDescriptor, resolveNativeProject, deriveModelViews, collectNativeConstraints, loadProjectSettings, resolveEffectiveRules, ruleCandidatesFromConstraints } from '@memoarchitect/tools';
-import { buildSourceGraph, sourceGraphToDTO, viewSourceFiles } from '@memoarchitect/tools';
+import { modelToDTO, apiPackageMetadata, loadMethodologyDescriptor, deriveModelViews, collectApiConstraints, loadProjectSettings, } from '@memoarchitect/tools';
+import { sourceGraphToDTO, viewSourceFiles } from '@memoarchitect/tools';
+import { buildSourceGraphFromPackages } from '../model/source-graph.js';
+import { computeWorkspaceMembership, selectWorkspace, workspaceMembershipToDTO } from '../model/workspace-membership.js';
 import { validateModel } from '@memoarchitect/tools';
 import { computeCompleteness } from '@memoarchitect/tools';
 import { createDevServer } from '../server/dev-server.js';
 import { createProjectWatcher, createOntologyWatcher } from '../server/file-watcher.js';
-import { checkLockFile } from '../lock.js';
+import { layoutBlindRevision } from '../model/view-layout-block.js';
+import { setReadOnlyRoots } from '../server/write-guard.js';
+import { readLegacyLayouts } from '../model/view-layout-migration.js';
+import { checkLockFile, lockableDependencies } from '../lock.js';
 import { findSysmlFiles } from '../model/sysml-files.js';
 import { enforceRuntimeBudget } from '../server/runtime-budget.js';
 import { withToolchainOverrides } from '../toolchain/schema.js';
+import { format } from 'node:util';
+import { sourceFingerprint } from '../toolchain/source-fingerprint.js';
+import { newToken, removeDevServerRecord, writeDevServerRecord } from '../server/dev-validate.js';
+import { createVersionServers } from '../server/version-servers.js';
+import { compileDeviceDhf } from '../dhf/device-dhf.js';
+import { evaluateWorkspaceGuide } from '../methodology/guide-service.js';
+import { computeChangeImpact } from '../model/impact.js';
+import { runValidation, validationExitCode } from './validate.js';
+import { compileResolvedProject } from '../toolchain/operations.js';
 import { resolveToolchain } from '../toolchain/effective.js';
 import { defaultRegistry } from '../toolchain/default-registry.js';
 import { computeStandardsReport, readDeclaredRegimes } from '../dhf/standards-report.js';
 import { loadStandardsLibrary } from '../dhf/standards-library.js';
+import { loadProjectModel, stage1CacheDir } from '../toolchain/project-model.js';
+import { apiEnumerations, apiProjectSourcePackages, resolutionLoads } from '../stage2/project-from-api.js';
+import { outlinesFromHandoff } from '../authoring/outline-source.js';
+import { outlineIdentityTable } from '../authoring/outline-identity.js';
+import { discoverProjectSources } from '../model/native-project.js';
+import { isRulePackageInScope, resolveProjectRules, scopedSubjectIds } from '../model/effective-scope.js';
+import { isProjectSource } from '../stage2/project-from-api.js';
+import { readClauseFacts } from '../validator/rule-clauses.js';
 /** Gather git info for model metadata */
 function getGitInfo(cwd) {
     const git = (cmd) => {
@@ -48,21 +70,6 @@ function getGitInfo(cwd) {
         gitDirty: porcelain ? true : undefined,
     };
 }
-/** Presentation enums are model facts, so ship their literal sets to the canvas. */
-function collectEnumerations(documents) {
-    const found = new Map();
-    const visit = (member) => {
-        if (member?.$type === 'EnumDefinition' && member.name) {
-            found.set(member.name, { name: member.name, literals: (member.literals ?? []).map((literal) => literal.name).filter(Boolean) });
-        }
-        for (const child of member?.members ?? [])
-            visit(child);
-    };
-    for (const document of documents)
-        for (const member of document.document.parseResult.value.members)
-            visit(member);
-    return [...found.values()];
-}
 /**
  * Strip stale relationship types from user diagrams, warn on any dropped.
  * Diagrams themselves are kept — only their stale relationshipType filter entries are removed.
@@ -100,7 +107,7 @@ function computeOntologyHash(registries) {
 export async function devCommand(options) {
     const bootstrapStartedAt = performance.now();
     const cwd = process.cwd();
-    const port = options.port || 3000;
+    const port = options.readOnly ? (options.port ?? 0) : (options.port || 3000);
     const host = '127.0.0.1';
     console.log(chalk.bold('\n🚀 MEMO Dev Server\n'));
     // ── bootstrap: runs once ───────────────────────────────────────────────────
@@ -109,18 +116,32 @@ export async function devCommand(options) {
     const toolchain = resolveToolchain(config, defaultRegistry);
     const gitInfo = getGitInfo(cwd);
     let buildCount = 0;
-    console.log(chalk.gray(`Project: ${config.projectName}`));
-    console.log(chalk.gray(`Toolchain: validator=${toolchain.validator} lowering=${toolchain.lowering} `
-        + `packager=${toolchain.packager}`));
+    console.log(chalk.gray(`Model: ${config.modelName}`));
+    console.log(chalk.gray(`Toolchain: ${toolchain.selections.map(s => `${s.role === 'package' ? 'packager' : s.role}=${s.provider}`).join(' ')}`));
     for (const note of toolchain.deprecations)
         console.log(chalk.yellow(`  ⚠ ${note}`));
-    const nativeResolution = await resolveNativeProject(cwd);
+    // The compiler resolves the project from what it compiled, so MEMO parses
+    // neither the ontology nor the closure; a stage 1 that reports an error
+    // stops here, as it stops `memo validate`.
+    let compiled;
+    try {
+        compiled = await loadProjectModel({ projectRoot: cwd, config });
+    }
+    catch (error) {
+        console.error(chalk.red(`\n❌ ${error instanceof Error ? error.message : error}\n`));
+        process.exit(1);
+    }
+    console.log(chalk.gray(`Stage 1: ${toolchain.lowering} ${compiled.providerVersion ?? ''}${compiled.cached ? ' (reused .memo/stage1)' : ''}`));
+    const nativeResolution = compiled.resolution ?? (() => {
+        console.error(chalk.red(`\n❌ ${toolchain.lowering} resolved no project: no entrypoint was compiled.\n`));
+        return process.exit(1);
+    })();
     for (const d of nativeResolution.diagnostics) {
         console.log(chalk.yellow(`  ⚠ ${d.code}: ${d.message}`));
     }
     const lockCheck = checkLockFile(cwd, nativeResolution.selectedRoots.map(root => ({
         ...root, origin: 'ontology', importDepth: 1,
-    })));
+    })), lockableDependencies(nativeResolution.dependencies));
     if (!lockCheck.ok) {
         console.error(chalk.red(`\n❌ ${lockCheck.message}\n`));
         process.exit(1);
@@ -132,38 +153,26 @@ export async function devCommand(options) {
     let ontologyRegistries;
     let ontologyRoots = [];
     let provenance;
-    let ontologyDocuments = [];
     let ontologyHash = '';
-    try {
-        const loadResult = await loadOntologyRegistries(cwd);
-        if (loadResult.fileCount > 0) {
-            ontologyRegistries = { ...loadResult.registries, provenance: loadResult.provenance };
-            // Include the resolved KPAR cache roots as restart-scoped library
-            // content. They must never be picked up by the project hot watcher.
-            ontologyRoots = [...new Set([
-                    ...loadResult.ontologyDirs,
-                    ...nativeResolution.selectedRoots.map(root => root.sysmlDir),
-                ])];
-            provenance = loadResult.provenance;
-            ontologyDocuments = loadResult.parsedDocuments;
-            if (ontologyRegistries.kindRegistry)
-                Object.freeze(ontologyRegistries.kindRegistry);
-            if (ontologyRegistries.relationshipRegistry)
-                Object.freeze(ontologyRegistries.relationshipRegistry);
-            ontologyHash = computeOntologyHash(ontologyRegistries);
-            const kr = loadResult.registries.kindRegistry;
-            const rr = loadResult.registries.relationshipRegistry;
-            console.log(chalk.gray(`Ontology: ${kr?.size ?? 0} kinds, ${rr?.size ?? 0} relationships ` +
-                `(from ${loadResult.fileCount} SysML files)`));
-        }
+    if (compiled.registries) {
+        ontologyRegistries = compiled.registries;
+        ontologyRoots = [...new Set(nativeResolution.selectedRoots.map(root => root.sysmlDir))];
+        provenance = compiled.registries.provenance;
+        if (ontologyRegistries.kindRegistry)
+            Object.freeze(ontologyRegistries.kindRegistry);
+        if (ontologyRegistries.relationshipRegistry)
+            Object.freeze(ontologyRegistries.relationshipRegistry);
+        ontologyHash = computeOntologyHash(ontologyRegistries);
+        console.log(chalk.gray(`Ontology: ${ontologyRegistries.kindRegistry?.size ?? 0} kinds, `
+            + `${ontologyRegistries.relationshipRegistry?.size ?? 0} relationships (from ${toolchain.lowering}'s handoff)`));
     }
-    catch (e) {
-        console.log(chalk.yellow(`  ⚠ Could not load ontology registries: ${e instanceof Error ? e.message : e}`));
+    else {
+        console.log(chalk.yellow(`  ⚠ ${toolchain.lowering}'s handoff stated no ontology registries`));
     }
     // Phase B — methodology descriptor (data-only; no UI consumer yet)
     let methodologyDescriptor = { folders: [], errors: [] };
     try {
-        methodologyDescriptor = await loadMethodologyDescriptor(cwd, nativeResolution);
+        methodologyDescriptor = await loadMethodologyDescriptor(cwd, nativeResolution, compiled.api);
         const folderCount = methodologyDescriptor.folders.length;
         const totalParts = methodologyDescriptor.folders.reduce((s, f) => s + Object.values(f.parts).reduce((a, p) => a + p.length, 0), 0);
         const totalDefs = methodologyDescriptor.folders.reduce((s, f) => s + f.partDefs.length, 0);
@@ -187,42 +196,130 @@ export async function devCommand(options) {
     }
     // ── end bootstrap ──────────────────────────────────────────────────────────
     // ── rebuildProject: hot path — no ontology reload ─────────────────────────
-    const projectParser = new IncrementalProjectParser(cwd);
     /** Revision of the newest rebuild that parsed — what a client is still showing. */
     let lastGoodRevision = 0;
+    /**
+     * What the last accepted stage 1 built: a rejected edit leaves the model,
+     * its identities, rules and registries where the last valid revision put
+     * them. There is no second opinion to fall back on.
+     */
+    /** The project as last built, for previewing and writing a user's rule. */
+    let ruleContext;
+    let latestClauses = [];
+    let lastPackages = [];
+    let lastAccepted;
+    // The newest compile, with the fingerprint of the sources it read (taken
+    // before it ran): what `memo validate` is answered from while the
+    // fingerprint still matches the files on disk.
+    let latestCompile;
+    /** The layout-blind revision of every source file as of the last rebuild. */
+    let lastSourceHashes = {};
     async function rebuildProject(changedFiles) {
         const rebuildStartedAt = performance.now();
         buildCount++;
+        const sysmlFiles = findSysmlFiles(cwd);
+        let errors = [];
+        // `toolchain.compiler` decides where the model comes from. A stage 1
+        // that reports errors makes this build incoherent, so a client keeps
+        // showing the last good one.
+        // The same resolved compile every command runs, reusing `.memo/stage1/`.
+        const fingerprint = sourceFingerprint(cwd);
+        const stage1 = await compileResolvedProject({ config, projectDir: cwd, cacheDir: stage1CacheDir(cwd) });
+        latestCompile = { fingerprint, stage1 };
+        // The methodology follows the project's imports, which an edit can
+        // change: from the compiled resolution.
         try {
-            methodologyDescriptor = await loadMethodologyDescriptor(cwd);
+            if (stage1.api)
+                methodologyDescriptor = await loadMethodologyDescriptor(cwd, stage1.resolution, stage1.api);
         }
         catch {
             // keep last good descriptor on transient parse failure
         }
-        const sysmlFiles = findSysmlFiles(cwd);
-        const { documents, errors } = await projectParser.parse(sysmlFiles, changedFiles);
-        const projectRegistries = ontologyRegistries
-            ? {
-                ...ontologyRegistries,
-                kindRegistry: ontologyRegistries.kindRegistry?.withProjectExtensions(documents),
-            }
+        if (!stage1.accepted || !stage1.model) {
+            errors = [...errors, ...stage1.diagnostics.filter(d => d.severity === 'error').map(d => ({
+                    file: d.file ?? '', line: d.range?.start.line, message: d.message, code: d.code,
+                }))];
+        }
+        const accepted = stage1.accepted && stage1.model && stage1.api;
+        const kept = !accepted ? lastAccepted : undefined;
+        // A rejected first build has nothing to keep: the dev server starts only
+        // from a valid project, so `lastAccepted` is set by the bootstrap compile.
+        if (!accepted && !kept)
+            throw new Error('No accepted build to show');
+        const model = accepted ? stage1.model : kept.model;
+        // Identities for the authoring write-back: each element's declaration in
+        // its file's outline (plans/memo-write-back-from-handoff.md), read from
+        // the handoff stage 1 built the model from.
+        const irIdentities = kept?.irIdentities ?? outlineIdentityTable(outlinesFromHandoff(resolve(cwd), stage1.api), model.elements.values(), resolve(cwd));
+        // An accepted stage 1 carries the ontology it resolved, rules included,
+        // so they are read from its handoff rather than from MEMO's own parse.
+        // The rules resolution loads, and the project's own: a rule the project
+        // wrote in a file nothing imports still runs, as in `memo validate`.
+        const resolutionOf = stage1.resolution ?? nativeResolution;
+        const ruleFileLoaded = resolutionOf
+            ? (file) => resolutionLoads(resolutionOf)(file) || isProjectSource(resolutionOf)(file)
+            : undefined;
+        // No write may land in a package the model depends on: it is shown, linked to, and changed elsewhere.
+        setReadOnlyRoots([...(resolutionOf?.closure.values() ?? [])]
+            .filter(pkg => pkg.origin === 'dependency' && pkg.root)
+            .flatMap(pkg => [pkg.root.dir, pkg.root.sysmlDir]));
+        const nativeConstraints = accepted
+            ? collectApiConstraints(stage1.api, undefined, stage1.resolution?.filePackages, ruleFileLoaded)
+            : kept.constraints;
+        // An accepted stage 1 states the ontology with the project's own kinds.
+        const stage2Registries = accepted && stage1.registries
+            ? stage1.registries
+            : kept?.registries;
+        // The effective rule set, activated and tailored as `memo validate` and
+        // `memo validate --rules` do it (`resolveProjectRules`), so Architect reports
+        // the rule set they do. Rule resolution must never take the rebuild down:
+        // a bad policy is a diagnostic about the methodology, not a reason the
+        // model cannot be shown.
+        let validation;
+        // Which workspace holds each element; also validated per workspace below, so a client shows a
+        // workspace's problems from the same computation `memo validate --workspace` runs.
+        const membership = stage2Registries?.kindRegistry && stage2Registries.relationshipRegistry
+            ? computeWorkspaceMembership(model, stage2Registries)
             : undefined;
-        const model = buildMemoModel(documents, config, errors, projectRegistries);
-        // Identities for the authoring write-back (§6.2). The surgical rebuild
-        // stays surgical — this lowers the documents it already parsed, and the
-        // provider-backed recompile happens on the write path, not here.
-        const irIdentities = irIdentityTable(lowerAstToSysmlIr(documents, modelToDTO(model), cwd));
-        const nativeConstraints = collectNativeConstraints([...ontologyDocuments, ...documents]);
-        const validation = validateModel(model, nativeConstraints, projectRegistries?.kindRegistry);
+        const validateWorkspaces = (run) => {
+            if (!membership || membership.missingSystem)
+                return;
+            const byWorkspace = {};
+            for (const workspace of membership.workspaces) {
+                const selection = selectWorkspace(model, membership, workspace.root);
+                if (selection.ok)
+                    byWorkspace[workspace.root] = run(selection.scope);
+            }
+            validation.byWorkspace = byWorkspace;
+        };
         const effectiveRuleSet = (() => {
             try {
-                const resolved = resolveEffectiveRules(ruleCandidatesFromConstraints(nativeConstraints), methodologyDescriptor.effective?.policyChain ?? []);
+                const kindRegistry = stage2Registries?.kindRegistry;
+                const filePackages = resolutionOf?.filePackages ?? new Map();
+                const { rules: resolved, scope } = resolveProjectRules({
+                    constraints: nativeConstraints,
+                    effective: methodologyDescriptor.effective,
+                    filePackages,
+                    kindSourceFile: kind => kindRegistry?.getKind(kind)?.sourceFile,
+                    isOwnFile: resolutionOf ? isProjectSource(resolutionOf) : undefined,
+                });
+                // Scope decides which elements rules RUN ON, not the model they navigate.
+                const inScopeIds = scope && scope.mode !== 'allAvailable'
+                    ? scopedSubjectIds(model, kind => {
+                        const sourceFile = kindRegistry?.getKind(kind)?.sourceFile;
+                        const declaringPackage = sourceFile ? filePackages.get(sourceFile) : undefined;
+                        return !declaringPackage || isRulePackageInScope(scope, declaringPackage);
+                    })
+                    : undefined;
+                const runRules = (workspace) => validateModel(model, resolved.activeConstraints, kindRegistry, resolved.rules, inScopeIds && (element => inScopeIds.has(element.id)), workspace, membership);
+                validation = runRules();
+                validateWorkspaces(runRules);
                 return { rules: resolved.rules, diagnostics: resolved.diagnostics };
             }
             catch (error) {
-                // Rule resolution must never take the rebuild down: a bad
-                // policy is a diagnostic about the methodology, not a reason
-                // the model cannot be shown.
+                const runNative = (workspace) => validateModel(model, nativeConstraints, stage2Registries?.kindRegistry, undefined, undefined, workspace, membership);
+                validation = runNative();
+                validateWorkspaces(runNative);
                 return {
                     rules: [],
                     diagnostics: [{
@@ -232,6 +329,18 @@ export async function devCommand(options) {
                 };
             }
         })();
+        // The clauses the model carries, to name and choose what a rule enforces.
+        // Only an accepted stage 1 states them; a rejected edit keeps the last.
+        if (accepted)
+            latestClauses = readClauseFacts(stage1.api);
+        const projectSourceFiles = discoverProjectSources(cwd).projectFiles;
+        effectiveRuleSet.clauses = latestClauses;
+        effectiveRuleSet.projectFiles = projectSourceFiles
+            .map(file => relative(cwd, file).replaceAll('\\', '/')).sort();
+        ruleContext = {
+            projectRoot: cwd, config, model, kindRegistry: stage2Registries?.kindRegistry,
+            constraints: nativeConstraints, clauses: latestClauses, projectFiles: new Set(projectSourceFiles.map(file => resolve(file))),
+        };
         const completeness = computeCompleteness(model, validation);
         console.log(chalk.cyan(`  ${model.elements.size} elements, ${model.relationships.length} relationships, ` +
             `${validation.violations.length} violations, ${completeness.overall}% complete`));
@@ -241,7 +350,7 @@ export async function devCommand(options) {
         const viewpoints = [];
         // Views modelled in SysML (DiagramView/DocumentView usages) surface as
         // viewpoint-grouped auto diagrams.
-        const derivedViews = deriveModelViews(model, projectRegistries?.kindRegistry);
+        const derivedViews = deriveModelViews(model, stage2Registries?.kindRegistry);
         viewpoints.push(...derivedViews.viewpoints);
         const diagrams = [];
         diagrams.push(...derivedViews.diagrams);
@@ -250,7 +359,8 @@ export async function devCommand(options) {
         const architectureLayers = undefined;
         const baseVersion = nativeResolution.selectedRoots[0]?.packageVersion || '0.1.0';
         const metadata = {
-            projectName: config.projectName,
+            modelName: config.modelName,
+            projectName: config.modelName, // deprecated alias, deleted in 0.15.0
             version: `${baseVersion}-dev.${buildCount}`,
             ...gitInfo,
         };
@@ -258,8 +368,8 @@ export async function devCommand(options) {
         if (existsSync(userDiagramsPath)) {
             try {
                 const rawUserDiagrams = JSON.parse(readFileSync(userDiagramsPath, 'utf8'));
-                const validUserDiagrams = projectRegistries
-                    ? validateDiagramsAgainstOntology(rawUserDiagrams, projectRegistries)
+                const validUserDiagrams = stage2Registries
+                    ? validateDiagramsAgainstOntology(rawUserDiagrams, stage2Registries)
                     : rawUserDiagrams;
                 diagrams.push(...validUserDiagrams);
             }
@@ -269,37 +379,49 @@ export async function devCommand(options) {
         }
         // Ship the ontology registries with the model so the client resolves
         // relationship legality from the ontology, not a hardcoded table.
-        const registriesDTO = projectRegistries
+        const registriesDTO = stage2Registries
             ? {
-                relationships: projectRegistries.relationshipRegistry?.toDefinitionDTOs() ?? [],
-                kinds: projectRegistries.kindRegistry?.toDefinitionDTOs() ?? [],
+                relationships: stage2Registries.relationshipRegistry?.toDefinitionDTOs() ?? [],
+                kinds: stage2Registries.kindRegistry?.toDefinitionDTOs() ?? [],
             }
             : undefined;
         // Which files can change what each view renders. Computed once per
         // rebuild so every client can answer "does this change affect me?"
         // locally, without a round trip per changed file.
-        const sourceGraph = buildSourceGraph(documents);
+        // From the handoff stage 1 built the model from.
+        const sourceGraph = accepted
+            ? (() => {
+                const { packages, files } = apiProjectSourcePackages(stage1.api, resolve(cwd));
+                return buildSourceGraphFromPackages(packages, files);
+            })()
+            : kept.sourceGraph;
+        const enumerations = accepted ? apiEnumerations(stage1.api) : kept.enumerations;
+        if (accepted) {
+            lastAccepted = { model, irIdentities, constraints: nativeConstraints, registries: stage2Registries, sourceGraph, enumerations, api: stage1.api };
+        }
         for (const diagram of diagrams) {
             diagram.sourceFiles = viewSourceFiles(diagram, model.elements, sourceGraph);
         }
+        lastSourceHashes = Object.fromEntries(sysmlFiles.map(file => [
+            relative(cwd, file).replaceAll('\\', '/'),
+            layoutBlindRevision(readFileSync(file, 'utf8')),
+        ]));
         const dto = modelToDTO(model, {
             viewpoints, architectureLayers, diagrams, registries: registriesDTO,
             revision: buildCount,
             sourceGraph: sourceGraphToDTO(sourceGraph),
             irIdentities,
-            sourceHashes: Object.fromEntries(sysmlFiles.map(file => [
-                relative(cwd, file).replaceAll('\\', '/'),
-                createHash('sha256').update(readFileSync(file)).digest('hex').slice(0, 16),
-            ])),
-            enumerations: collectEnumerations(documents),
+            sourceHashes: lastSourceHashes,
+            enumerations,
+            workspaceMembership: membership ? workspaceMembershipToDTO(membership, model) : undefined,
         });
         // Compute the clause coverage report and attach it to the model DTO
         // so the Architect can badge document cards with gap counts without a
-        // second request. Same computation as `memo standards check`.
+        // second request. Same computation as `memo validate --standards`.
         try {
             const library = loadStandardsLibrary(cwd);
-            const kindRegistry = projectRegistries?.kindRegistry;
-            const declared = readDeclaredRegimes(model);
+            const kindRegistry = stage2Registries?.kindRegistry;
+            const declared = readDeclaredRegimes(model, kindRegistry);
             dto.standardsReport = computeStandardsReport({
                 library,
                 model,
@@ -314,7 +436,11 @@ export async function devCommand(options) {
         }
         dto.metadata = metadata;
         dto.ontologyHash = ontologyHash;
-        const ontologyPackages = getPackageMetadata(cwd);
+        // The packages of the last accepted build: a rejected edit keeps them.
+        if (accepted) {
+            lastPackages = apiPackageMetadata(stage1.api, cwd, new Set(nativeResolution.selectedRoots.map(root => root.dir)), resolutionOf?.filePackages);
+        }
+        const ontologyPackages = lastPackages;
         if (errors.length === 0)
             lastGoodRevision = buildCount;
         const result = {
@@ -346,11 +472,20 @@ export async function devCommand(options) {
     if (sysmlCount === 0) {
         console.log(chalk.yellow('  ⚠ No .sysml files found in this directory.'));
         console.log(chalk.gray('  Create model files in a model/ subdirectory, or run:'));
-        console.log(chalk.gray('    memo init <project-name>'));
-        console.log(chalk.gray('    memo import template elements\n'));
+        console.log(chalk.gray('    memo-architect init <project-name>'));
+        console.log(chalk.gray('    memo-architect import template elements\n'));
     }
     console.log(chalk.gray('  Building model...'));
     const initial = await rebuildProject();
+    // Layouts moved into their views; a sidecar left behind is no longer read.
+    try {
+        const leftover = readLegacyLayouts(cwd);
+        if (leftover.length > 0) {
+            console.log(chalk.yellow(`  ⚠ ${leftover.length} diagram layout(s) in .viewlayout files are no longer read. `
+                + 'Run `memo-architect migrate-layout` to move them into their views.'));
+        }
+    }
+    catch { /* a warning, never a reason not to serve */ }
     let shuttingDown = false;
     let idleShutdownTimer;
     let projectWatcher;
@@ -362,19 +497,116 @@ export async function devCommand(options) {
         if (idleShutdownTimer)
             clearTimeout(idleShutdownTimer);
         console.log(chalk.gray(`\n  ${reason}`));
+        if (layoutSettleTimer)
+            clearTimeout(layoutSettleTimer);
         projectWatcher?.close();
         ontologyWatcher?.close();
+        versions?.close();
+        removeDevServerRecord(cwd);
         server.close();
         process.exit(0);
     };
+    // Compiles run one at a time, whether a save or a `memo validate` asked.
+    let compileChain = Promise.resolve();
+    const serialized = (run) => {
+        const next = compileChain.then(run, run);
+        compileChain = next.then(() => undefined, () => undefined);
+        return next;
+    };
+    // `memo validate`, answered from the model held here (server/dev-validate.ts).
+    // The settings are read once, at startup: changed since, this process is
+    // not the one to validate them, and the caller validates on its own.
+    const settingsAtStart = JSON.stringify(loadProjectSettings(cwd));
+    const validateToken = newToken();
+    const validateHere = (validateOptions) => serialized(async () => {
+        if (JSON.stringify(loadProjectSettings(cwd)) !== settingsAtStart) {
+            throw new Error('the project settings changed since memo dev started');
+        }
+        if (latestCompile?.fingerprint !== sourceFingerprint(cwd))
+            await rebuildAndPublish([]);
+        const held = latestCompile;
+        if (!held)
+            throw new Error('memo dev holds no compile');
+        let stdout = '';
+        let stderr = '';
+        const io = {
+            out: (...args) => { stdout += format(...args) + '\n'; },
+            err: (...args) => { stderr += format(...args) + '\n'; },
+            write: text => { stdout += text; },
+        };
+        const exitCode = await validationExitCode(() => runValidation(cwd, validateOptions, io, async () => held.stage1));
+        return { exitCode, stdout, stderr };
+    });
     // Start dev server
+    const versions = options.versionChild && !options.readOnly
+        ? createVersionServers({
+            projectRoot: cwd, entry: options.versionChild.entry, args: options.versionChild.args,
+            workingModel: () => lastAccepted?.model, workingUrl: () => `http://${host}:${workingPort}`,
+            toolchain: config.toolchain,
+        })
+        : undefined;
+    let workingPort = port;
+    const devices = options.readOnly ? undefined : {
+        generate: (device) => {
+            if (!lastAccepted)
+                throw new Error('the working model is not built yet');
+            return compileDeviceDhf({
+                projectRoot: cwd, working: { model: lastAccepted.model, registries: lastAccepted.registries },
+                device, outputDir: resolve(cwd, 'dhf-output'), config: { toolchain: config.toolchain },
+            });
+        },
+    };
+    // Where the model stands against its method, for one workspace. Read-only: it writes nothing.
+    const guide = {
+        evaluate: (workspace) => {
+            if (!lastAccepted?.api || !lastAccepted.registries)
+                throw new Error('the working model is not built yet');
+            const packages = (methodologyDescriptor.effective?.chain ?? []).map(m => m.packageQualifiedName).filter((p) => !!p);
+            return evaluateWorkspaceGuide({
+                api: lastAccepted.api, model: lastAccepted.model, registries: lastAccepted.registries,
+                constraints: lastAccepted.constraints, packages, workspace,
+            });
+        },
+    };
+    // What the working tree's change reaches, measured from the commit it branched from (T11).
+    const impact = options.readOnly ? undefined : {
+        compute: (target) => {
+            if (!lastAccepted?.api || !lastAccepted.registries)
+                throw new Error('the working model is not built yet');
+            const packages = (methodologyDescriptor.effective?.chain ?? []).map(m => m.packageQualifiedName).filter((p) => !!p);
+            return computeChangeImpact({
+                projectRoot: cwd, target,
+                head: { model: lastAccepted.model, registries: lastAccepted.registries, api: lastAccepted.api, constraints: lastAccepted.constraints, packages },
+                build: { config: { toolchain: config.toolchain } },
+            });
+        },
+    };
     const server = await createDevServer({
+        memoModel: () => lastAccepted?.model,
+        workspaceScope: root => {
+            if (!lastAccepted?.registries?.kindRegistry || !lastAccepted.registries.relationshipRegistry)
+                return undefined;
+            const membership = computeWorkspaceMembership(lastAccepted.model, lastAccepted.registries);
+            const selection = selectWorkspace(lastAccepted.model, membership, root);
+            return selection.ok ? selection.scope : undefined;
+        },
+        impact,
+        guide,
+        devices,
+        versions,
+        readOnly: options.readOnly,
+        pinned: options.pinned,
+        preferencesRoot: options.preferencesRoot,
+        validate: validateHere,
+        validateToken,
         port,
         projectRoot: cwd,
         webPackagePath: options.clientRoot,
         initialMessages: initial.messages,
+        ruleContext: () => ruleContext,
         ontologyRegistries,
         ontologyRoots,
+        packageMetadata: () => lastPackages,
         relationshipFiles: config.relationshipFiles,
         canonicalRelationshipFile: config.canonicalRelationshipFile,
         transformClientHtml: options.transformClientHtml,
@@ -396,6 +628,14 @@ export async function devCommand(options) {
             }
         },
     });
+    // Say where `memo validate` can find this model. Not when this run names a
+    // toolchain of its own: a plain `memo validate` would then be answered by
+    // another compiler than the settings select.
+    const ownToolchain = Object.values(options.toolchainOptions ?? {}).some(value => value !== undefined);
+    if (!ownToolchain && !options.readOnly) {
+        writeDevServerRecord({ pid: process.pid, url: `http://${host}:${port}`, token: validateToken, projectRoot: cwd });
+        process.once('exit', () => removeDevServerRecord(cwd));
+    }
     if (!initial.coherent) {
         // Starting on a project that does not parse is allowed — the user
         // opened Architect precisely to see and fix it. There is no last good
@@ -417,7 +657,15 @@ export async function devCommand(options) {
         : performance.now() - bootstrapStartedAt;
     const runtimeBudget = enforceRuntimeBudget(budgetPath, elapsed);
     console.log(chalk.gray(`  ${budgetPath}: ${runtimeBudget.elapsedMs.toFixed(0)}ms / ${runtimeBudget.budgetMs}ms`));
-    console.log(chalk.green(`\n  ➜ http://${host}:${port}\n`));
+    const boundPort = options.readOnly ? server.port : port;
+    workingPort = boundPort;
+    console.log(chalk.green(`\n  ➜ http://${host}:${boundPort}\n`));
+    // A pinned server is a child of the server that opened it: it tells that parent where it is, and
+    // goes when the parent does.
+    if (options.readOnly && process.send) {
+        process.send({ type: 'memo:read-only-ready', url: `http://${host}:${boundPort}` });
+        process.once('disconnect', () => process.exit(0));
+    }
     // ── notifyRestartRequired: ontology watcher callback ───────────────────────
     // Declared after server so it can reference server directly.
     function notifyRestartRequired(reason, changedFile) {
@@ -447,7 +695,8 @@ export async function devCommand(options) {
             }, 50);
         }
     }
-    // Project watcher — hot reload.
+    // Project watcher — hot reload. Not in a read-only server: the directory is a pinned commit and
+    // does not change under it.
     //
     // The rebuild is broadcast together with the list of files that caused it,
     // so open editors and views can tell whether the change was theirs instead
@@ -482,7 +731,7 @@ export async function devCommand(options) {
                 })),
                 lastGoodRevision,
             });
-            console.log(chalk.yellow(`  ⚠ ${result.firstErrorFile ?? 'project source'} does not parse — showing the last good model`
+            console.log(chalk.yellow(`  ⚠ ${result.firstErrorFile ?? 'project source'} does not compile — showing the last good model`
                 + ` (revision ${lastGoodRevision}). Mutations are held until it does.`));
             return;
         }
@@ -496,8 +745,17 @@ export async function devCommand(options) {
                 },
             }]);
     };
-    projectWatcher = createProjectWatcher(cwd, async (changedFiles) => {
-        for (const file of changedFiles)
+    // A layout is saved at the end of a drag, into the view that declares it. Such a
+    // write changes no model fact, so it does not rebuild at once: the clients that
+    // did not make it are given the new layout, and one rebuild follows when the
+    // saves stop. That rebuild is not for the model's sake but for the source
+    // ranges the compile recorded, which a block of statements shifts for every
+    // declaration after it in the file.
+    const LAYOUT_SETTLE_MS = 2500;
+    let layoutSettleTimer;
+    const settlingLayoutFiles = new Set();
+    const runRebuilds = async (files) => {
+        for (const file of files)
             pendingRebuildFiles.add(file);
         if (rebuildInFlight)
             return;
@@ -506,15 +764,46 @@ export async function devCommand(options) {
             while (pendingRebuildFiles.size > 0) {
                 const nextFiles = [...pendingRebuildFiles].sort();
                 pendingRebuildFiles.clear();
-                await rebuildAndPublish(nextFiles);
+                await serialized(() => rebuildAndPublish(nextFiles));
             }
         }
         finally {
             rebuildInFlight = false;
         }
-    }, 300, false, { ontologyRoots, provenance });
+    };
+    if (!options.readOnly)
+        projectWatcher = createProjectWatcher(cwd, async (changedFiles) => {
+            const layoutOnly = changedFiles.filter(file => {
+                const known = lastSourceHashes[file.replaceAll('\\', '/')];
+                const path = resolve(cwd, file);
+                return known !== undefined && existsSync(path) && layoutBlindRevision(readFileSync(path, 'utf8')) === known;
+            });
+            const rest = changedFiles.filter(file => !layoutOnly.includes(file));
+            if (layoutOnly.length > 0) {
+                const mine = server.consumeWriteTransactions(layoutOnly).matched;
+                const outside = layoutOnly.filter(file => !(file.replaceAll('\\', '/') in mine));
+                if (outside.length > 0)
+                    server.refreshLayouts(outside);
+                // Whatever else changed in the same burst rebuilds anyway, and that
+                // rebuild covers these files; otherwise settle first.
+                if (rest.length === 0) {
+                    for (const file of layoutOnly)
+                        settlingLayoutFiles.add(file);
+                    if (layoutSettleTimer)
+                        clearTimeout(layoutSettleTimer);
+                    layoutSettleTimer = setTimeout(() => {
+                        const files = [...settlingLayoutFiles];
+                        settlingLayoutFiles.clear();
+                        void runRebuilds(files);
+                    }, LAYOUT_SETTLE_MS);
+                    return;
+                }
+            }
+            await runRebuilds(rest.length > 0 ? changedFiles : []);
+        }, 300, false, { ontologyRoots, provenance });
     // Ontology watcher — restart notification only, no registry reload
-    ontologyWatcher = createOntologyWatcher(cwd, ontologyRoots, (changedFile) => notifyRestartRequired('ontology-source-changed', changedFile), 300, provenance);
+    if (!options.readOnly)
+        ontologyWatcher = createOntologyWatcher(cwd, ontologyRoots, (changedFile) => notifyRestartRequired('ontology-source-changed', changedFile), 300, provenance);
     // Open browser
     if (options.open !== false) {
         const openModule = await import('open');