@memoarchitect/tools 0.13.2 → 0.15.1

package/packages/tools/lib/server/dev-server.js

@@ -4,7 +4,9 @@
 //   - Optional client middleware supplied by a higher-level application
 //   - WebSocket endpoint for pushing model updates to browser
 // ─────────────────────────────────────────────────────────────────────────────
+import { serveValidate } from './dev-validate.js';
 import { createServer as createHttpServer } from 'node:http';
+import { createServer as createNetServer } from 'node:net';
 import { createHash, randomUUID } from 'node:crypto';
 import { isAbsolute, relative, resolve } from 'node:path';
 import { existsSync, readFileSync, realpathSync, writeFileSync, mkdirSync, createReadStream, statSync } from 'node:fs';
@@ -12,25 +14,34 @@ import { extname } from 'node:path';
 import { findMemoManifests, validateRelationshipMutation, validateRelationshipDeletion } from '@memoarchitect/tools';
 import { indexFromIdentityTable } from '../model/ir-identity.js';
 import { recompileProject, writeElement } from '../operations/authoring.js';
-import { isWritableRelationshipFile, removeRelationship, resolveRelationshipPlacement, updateRelationship, writeRelationship, } from './relationship-writer.js';
+import { isWritableRelationshipFile, removeRelationship, resolveRelationshipPlacement, reviewTraceBaselines, updateRelationship, writeRelationship, } from './relationship-writer.js';
+import { resolveSuspectReviews } from './suspect-review.js';
+import { prepareSourceImport } from '../import/source-import.js';
+import { dtoToModel } from '../model/semantic.js';
 import { removeElement } from './element-writer.js';
 import { projectEntrypoint } from '../model/native-project.js';
 import { createPackage, deletePackage, moveElementToPackage, moveIntoGroupingPackage, movePackage, renamePackage, } from './package-writer.js';
-import { assertSingleDomainMutation, MixedMutationDomainError } from './mutation-domain.js';
+import { writeRelease } from './release-writer.js';
+import { assertSingleDomainMutation, isReadOnlyMessage, MixedMutationDomainError } from './mutation-domain.js';
 import { classifyConflict } from './conflict-policy.js';
 import { checkRulePolicy, insertRulePolicy, renderRulePolicy } from './rule-policy-writer.js';
+import { createRule, previewRule } from './rule-service.js';
 import { loadViewLayouts, saveViewLayout } from './view-layout-store.js';
-import { updateViewExpose, writeViewDeclaration } from './view-writer.js';
+import { layoutBlindRevision } from '../model/view-layout-block.js';
+import { assertWritable } from './write-guard.js';
+import { updateViewDisplay, updateViewExpose, writeViewDeclaration } from './view-writer.js';
 import { usageKeyword } from '../model/semantic.js';
 import { loadDhfDocs, saveDhfDoc, deleteDhfDoc, loadDhfSettings, saveDhfSettings, listRepoTemplates, readRepoTemplate, saveRepoTemplate, } from './dhf-doc-store.js';
 import { loadDashboards, saveDashboard, deleteDashboard, moveDashboard } from './dashboard-store.js';
+import { loadUserPreferences, saveUserPreferences } from './user-preferences.js';
 import { createDashboardWatcher } from './file-watcher.js';
+import { selectedOutlineSource } from '../authoring/outline-source.js';
 const MODEL_MUTATION_MESSAGES = new Set([
     'element:update', 'element:create', 'element:delete', 'element:remap-kinds', 'element:move-package',
     'package:create', 'package:rename', 'package:delete', 'package:move',
-    'relationship:create', 'relationship:delete', 'relationship:update',
-    'diagram:create', 'diagram:update', 'diagram:delete', 'diagram:layout:update', 'diagram:source:save',
-    'methodology:source:save', 'csv:import', 'screen-capture:upload',
+    'relationship:create', 'relationship:delete', 'relationship:update', 'release:create',
+    'diagram:create', 'diagram:update', 'diagram:display:update', 'diagram:delete', 'diagram:layout:update', 'diagram:source:save',
+    'methodology:source:save', 'csv:import', 'import:apply', 'suspect:review', 'screen-capture:upload',
     'ontology:install', 'ontology:remove', 'ontology:save-selection',
     'dhf:doc:save', 'dhf:doc:delete', 'dhf:settings:save', 'dhf:template:save',
     'llm:chat:apply', 'llm:settings:save',
@@ -174,6 +185,10 @@ export async function createDevServer(options) {
     // three state payloads from a rebuild share one revision so the browser
     // cannot combine a model from one build with validation from another.
     const workspaceSessionId = randomUUID();
+    /** The model writes in flight, in order. */
+    let mutationQueue = Promise.resolve();
+    /** The newest layout message seen for each diagram. */
+    const latestLayoutMessage = new Map();
     const writeTransactions = new Map();
     let workspaceRevision = 1;
     let mutationLockout;
@@ -216,7 +231,8 @@ export async function createDevServer(options) {
     function recordWriteTransaction(sourceFile, text) {
         const id = randomUUID();
         writeTransactions.set(sourceFile.replaceAll('\\', '/'), {
-            id, hash: createHash('sha256').update(text).digest('hex').slice(0, 16),
+            // The same revision the watcher's match is made with, which ignores layout.
+            id, hash: fileRevision(text),
             createdAt: Date.now(), unmatchedWrites: 0,
         });
         return id;
@@ -331,6 +347,11 @@ export async function createDevServer(options) {
             server: {
                 middlewareMode: true,
                 host,
+                // Vite's HMR socket defaults to 24678, one per machine. A second
+                // dev server (or a stale one) finds it taken, logs a port error,
+                // and its page's HMR client keeps failing to connect to a socket
+                // that belongs to somebody else's server. Each server takes its own.
+                hmr: { port: await freePort(host) },
                 watch: { ignored: isModelOwnedWatchPath },
             },
             appType: 'spa',
@@ -339,6 +360,8 @@ export async function createDevServer(options) {
                 : [],
         });
         server = createHttpServer((req, res) => {
+            if (serveValidate(req, res, options.validateToken, options.validate))
+                return;
             if (serveProjectAsset(req, res))
                 return;
             if (serveHelp(req, res))
@@ -349,6 +372,8 @@ export async function createDevServer(options) {
     else if (hasWebDist) {
         // Packaged install: serve the prebuilt web app statically
         server = createHttpServer((req, res) => {
+            if (serveValidate(req, res, options.validateToken, options.validate))
+                return;
             if (serveProjectAsset(req, res))
                 return;
             if (serveHelp(req, res))
@@ -359,6 +384,8 @@ export async function createDevServer(options) {
     else {
         // Fallback: serve a basic page that connects via WebSocket
         server = createHttpServer((req, res) => {
+            if (serveValidate(req, res, options.validateToken, options.validate))
+                return;
             if (serveProjectAsset(req, res))
                 return;
             res.writeHead(200, { 'Content-Type': 'text/html' });
@@ -404,7 +431,7 @@ export async function createDevServer(options) {
     // Every view is DECLARED in SysML — see `view-writer.ts`. The sidecar at
     // .memo/user-diagrams.json used to be merged in here as a second class of
     // view, which is how a view could exist for Architect and for nothing else:
-    // no source file, so invisible to `memo validate`, to `syside check`, to
+    // no source file, so invisible to `memo validate`, to the selected compiler, to
     // review, and — wherever `.memo/` is ignored — to git.
     //
     // Rows left in that file are therefore not views but UNDECLARED views: an
@@ -551,6 +578,13 @@ export async function createDevServer(options) {
      * Cleared by `broadcast`, because a published model supersedes it.
      */
     let writeBackIndex;
+    /**
+     * A recompiled index, when it addresses anything. A compiler that builds
+     * the model from its handoff states no syntax tree, so its recompile
+     * mints no identities; adopting that empty index would refuse every
+     * further write until the watcher republished. The published one stands.
+     */
+    const addressable = (index) => index.byIdentity.size > 0 ? index : writeBackIndex;
     /** The index every write resolves its identities against. */
     const irIndex = () => writeBackIndex ?? indexFromIdentityTable(currentModel()?.irIdentities);
     /**
@@ -566,17 +600,19 @@ export async function createDevServer(options) {
     /** What every authoring operation is given: the project, its settings, and the index. */
     async function authoringContext() {
         const { loadAndResolveConfig } = await import('./config-resolver.js');
-        const { findConfigFile } = await import('@memoarchitect/tools');
+        const { findConfigFile, loadProjectSettings } = await import('@memoarchitect/tools');
         const configPath = findConfigFile(options.projectRoot);
+        const config = configPath ? loadAndResolveConfig(configPath) : loadProjectSettings(options.projectRoot);
         return {
             projectDir: options.projectRoot,
-            config: configPath ? loadAndResolveConfig(configPath) : undefined,
+            config,
             irIndex: irIndex(),
+            outlines: selectedOutlineSource(options.projectRoot, config),
         };
     }
     async function recompileAfterWrite() {
         try {
-            writeBackIndex = (await recompileProject(await authoringContext())).index;
+            writeBackIndex = addressable((await recompileProject(await authoringContext())).index);
         }
         catch (e) {
             // A recompile that fails leaves the previous index in place: the
@@ -586,33 +622,54 @@ export async function createDevServer(options) {
             console.warn(`[Authoring] Recompile after write failed: ${e instanceof Error ? e.message : String(e)}`);
         }
     }
+    /**
+     * What the query engines read: the model the last build made (not the DTO clients are sent, which has no
+     * indexes to query), the validation and completeness the server holds, and, when the person is working in
+     * one workspace, its scope, so a question about one system is answered from that system.
+     */
+    async function scopedQueryContext(config, workspaceRoot) {
+        const { createQueryContext } = await import('../dhf/query-engine.js');
+        const model = options.memoModel?.();
+        if (!model)
+            throw new Error('The model is not built yet.');
+        const validMsg = initialMessages.find(m => m.type === 'validation:update');
+        const compMsg = initialMessages.find(m => m.type === 'completeness:update');
+        const scope = workspaceRoot ? options.workspaceScope?.(workspaceRoot) : undefined;
+        return createQueryContext(model, validMsg?.payload ?? { violations: [] }, compMsg?.payload ?? { overall: 0, layers: [] }, config, undefined, scope);
+    }
     /**
      * Build the query context the LLM engines read from, against whatever the
      * server currently holds. Every LLM handler needs the same four pieces, so
      * they share this rather than each re-deriving them.
      */
-    async function llmQueryContext() {
-        const { createQueryContext, findConfigFile, loadOntologyRegistries, ontologyViewFrom, EMPTY_ONTOLOGY_VIEW } = await import('@memoarchitect/tools');
+    async function llmQueryContext(workspaceRoot) {
+        const { findConfigFile, loadProjectOntology, ontologyViewFrom, EMPTY_ONTOLOGY_VIEW } = await import('@memoarchitect/tools');
         const { loadAndResolveConfig } = await import('./config-resolver.js');
         const modelMsg = initialMessages.find(m => m.type === 'model:update');
         const validMsg = initialMessages.find(m => m.type === 'validation:update');
         const compMsg = initialMessages.find(m => m.type === 'completeness:update');
         const configPath = findConfigFile(options.projectRoot);
-        const config = configPath ? loadAndResolveConfig(configPath) : { projectName: 'untitled' };
+        const config = configPath ? loadAndResolveConfig(configPath) : { modelName: 'untitled' };
         // Kinds and relationships come from the resolved SysML, not from the
         // settings file the config path points at.
         let ontology = EMPTY_ONTOLOGY_VIEW;
         try {
-            const loaded = await loadOntologyRegistries(options.projectRoot);
+            const loaded = await loadProjectOntology({ projectRoot: options.projectRoot, config });
             ontology = ontologyViewFrom(loaded.registries.kindRegistry, loaded.registries.relationshipRegistry);
         }
         catch {
             // A project whose ontology does not resolve still has a model to query.
         }
-        const ctx = createQueryContext(modelMsg?.payload ?? {}, validMsg?.payload ?? { violations: [] }, compMsg?.payload ?? { overall: 0, layers: [] }, config);
+        const ctx = await scopedQueryContext(config, workspaceRoot);
         return { ctx, config, ontology };
     }
     /** Settings status for the client — provider/model/origin, never the key. */
+    async function toolchainSettings() {
+        const { userToolchainStatus } = await import('../toolchain/user-settings-status.js');
+        const { defaultRegistry } = await import('../toolchain/default-registry.js');
+        const { loadProjectSettings } = await import('../model/config-loader.js');
+        return userToolchainStatus(defaultRegistry, {}, process.env, loadProjectSettings(options.projectRoot).projectToolchain ?? {});
+    }
     async function llmSettings() {
         const { llmSettingsStatus } = await import('@memoarchitect/tools');
         return llmSettingsStatus(options.projectRoot);
@@ -641,7 +698,7 @@ export async function createDevServer(options) {
                     layer: change.layer ?? kindDef?.layer ?? '',
                     doc: change.doc ?? '',
                     attributes: change.attributes ?? {},
-                });
+                }, irIndex(), (await authoringContext()).outlines);
                 if (!result.success)
                     throw new Error(result.error ?? 'Failed to write the element.');
                 await recompileAfterWrite();
@@ -656,7 +713,7 @@ export async function createDevServer(options) {
                     ...(change.changes.name !== undefined ? { name: change.changes.name } : {}),
                     ...(change.changes.doc !== undefined ? { doc: change.changes.doc } : {}),
                     attributes: { ...existing.attributes, ...(change.changes.attributes ?? {}) },
-                }, irIndex());
+                }, irIndex(), (await authoringContext()).outlines);
                 if (!result.success)
                     throw new Error(result.error ?? 'Failed to write the element.');
                 await recompileAfterWrite();
@@ -705,13 +762,14 @@ export async function createDevServer(options) {
                 ?? registries?.kindRegistry?.toDefinitionDTOs() ?? [],
         };
     }
-    function relationshipWriterOptions() {
+    async function relationshipWriterOptions() {
         return {
             projectRoot: options.projectRoot,
             ontologyRoots: options.ontologyRoots,
             designatedFiles: options.relationshipFiles,
             canonicalFile: options.canonicalRelationshipFile,
             irIndex: irIndex(),
+            outlines: (await authoringContext()).outlines,
         };
     }
     /**
@@ -735,7 +793,7 @@ export async function createDevServer(options) {
         if (!model)
             return reject('The model is not loaded yet.');
         const registries = serverRegistries();
-        const writerOptions = relationshipWriterOptions();
+        const writerOptions = await relationshipWriterOptions();
         // The active view's profile only downgrades to a warning, so a
         // relationship the view cannot draw is still created in the model.
         const diagram = payload.diagramId
@@ -789,6 +847,29 @@ export async function createDevServer(options) {
             },
         };
     }
+    /** Create one release record with all its statements, or none. */
+    async function handleReleaseCreate(payload) {
+        const requestId = payload?.requestId ?? '';
+        const reject = (error) => ({ type: 'release:create:result', payload: { requestId, success: false, error } });
+        const conflict = checkMutationPrecondition(payload.precondition, requestId, payload);
+        if (conflict)
+            return reject(conflict);
+        const model = currentModel();
+        if (!model)
+            return reject('The model is not loaded yet.');
+        const result = await writeRelease(payload, {
+            projectRoot: options.projectRoot,
+            outlines: (await authoringContext()).outlines,
+            fileOf: id => model.elements[id]?.file,
+            commitOf: id => model.elements[id]?.attributes?.modelCommit,
+        });
+        if (!result.success)
+            return reject(result.error ?? 'The release could not be written.');
+        console.log(`[Persisted] release ${result.name} (${result.modelCommit?.slice(0, 7)}) to ${result.filePath}`);
+        recordWriteTransaction(result.filePath, readFileSync(resolve(options.projectRoot, result.filePath), 'utf8'));
+        await recompileAfterWrite();
+        return { type: 'release:create:result', payload: { requestId, ...result } };
+    }
     /** Delete one relationship usage, leaving both endpoint elements in place. */
     async function handleRelationshipDelete(payload) {
         const requestId = payload?.requestId ?? '';
@@ -810,7 +891,7 @@ export async function createDevServer(options) {
             const first = validation.diagnostics[0];
             return reject(first?.message ?? 'The relationship was not found.', validation.diagnostics);
         }
-        const result = await removeRelationship(validation.relationship, relationshipWriterOptions());
+        const result = await removeRelationship(validation.relationship, await relationshipWriterOptions());
         if (!result.success) {
             console.error(`[Relationship] Delete failed: ${result.error}`);
             return reject(result.error ?? 'The relationship could not be removed.');
@@ -831,6 +912,96 @@ export async function createDevServer(options) {
             },
         };
     }
+    /**
+     * Preview or apply an import from another system. A preview writes nothing; an
+     * apply writes the one file the source owns, then recompiles. Both run the
+     * same computation, so the preview is what the apply does.
+     */
+    async function handleSourceImport(mode, payload) {
+        const requestId = payload?.requestId ?? '';
+        const fail = (...errors) => ({
+            type: 'source-import:result', payload: { requestId, mode, success: false, errors },
+        });
+        const model = currentModel();
+        const registries = options.ontologyRegistries;
+        if (!model)
+            return fail('The model is not loaded yet.');
+        if (!registries?.kindRegistry || !registries.relationshipRegistry)
+            return fail('The ontology is not loaded yet.');
+        if (!payload.system?.trim())
+            return fail('Name the system the export came from.');
+        const context = { kindRegistry: registries.kindRegistry, relationshipRegistry: registries.relationshipRegistry };
+        const prepared = prepareSourceImport(dtoToModel(model), context, {
+            system: payload.system.trim(), format: payload.format, text: payload.text,
+            defaultKind: payload.kind, defaultRelation: payload.relation,
+        }, { sourceFile: payload.fileName });
+        const { records, preview, rendered } = prepared;
+        // An export that read nothing must not look like a source that dropped every record.
+        if (records.errors.length > 0 && records.items.length === 0 && !records.partial)
+            return fail(...records.errors);
+        const target = resolve(options.projectRoot, rendered.file);
+        const base = {
+            requestId, mode, success: true, preview, dropped: rendered.dropped,
+            warnings: [...records.warnings, ...rendered.warnings], errors: records.errors,
+            sourceFile: rendered.file,
+            sourceHash: existsSync(target) ? fileRevision(readFileSync(target, 'utf8')) : '',
+        };
+        if (mode === 'preview')
+            return { type: 'source-import:result', payload: base };
+        // The preview named the file this writes and the hash the client saw of it; if the file has
+        // changed since (a second tab, a CLI import, a text edit), what the person reviewed is not
+        // what this would do.
+        if (payload.precondition?.sourceFile !== rendered.file)
+            return fail('The apply is not for the file this import writes; preview it again.');
+        const conflict = checkMutationPrecondition(payload.precondition, requestId, payload);
+        if (conflict)
+            return fail(conflict);
+        if (!isWritableRelationshipFile(rendered.file, await relationshipWriterOptions()))
+            return fail(`${rendered.file} is not a writable project file`);
+        mkdirSync(resolve(target, '..'), { recursive: true });
+        assertWritable(target);
+        writeFileSync(target, rendered.text, 'utf-8');
+        recordWriteTransaction(rendered.file, rendered.text);
+        console.log(`[Import] ${payload.system}: wrote ${rendered.file}`);
+        await recompileAfterWrite();
+        return { type: 'source-import:result', payload: base };
+    }
+    /**
+     * Mark suspect links reviewed: each is rewritten to the current revision of the
+     * record it was suspect about. What is suspect is decided here from the whole
+     * model, never from the request, so a stale or invented link is refused.
+     */
+    async function handleSuspectReview(payload) {
+        const requestId = payload?.requestId ?? '';
+        const reject = (error) => ({
+            type: 'suspect:review:result', payload: { requestId, success: false, reviewed: [], error },
+        });
+        if (!payload.preconditions?.length)
+            return reject('The review has no source preconditions; reload before saving.');
+        for (const precondition of payload.preconditions) {
+            const conflict = checkMutationPrecondition(precondition, requestId, payload);
+            if (conflict)
+                return reject(conflict);
+        }
+        const model = currentModel();
+        if (!model)
+            return reject('The model is not loaded yet.');
+        const resolved = resolveSuspectReviews(model, payload.reviews ?? []);
+        if ('error' in resolved)
+            return reject(resolved.error);
+        const { reviews } = resolved;
+        const result = await reviewTraceBaselines(reviews, await relationshipWriterOptions());
+        if (!result.success)
+            return reject(result.error ?? 'The review could not be written.');
+        for (const file of result.sourceFiles ?? []) {
+            recordWriteTransaction(file, readFileSync(resolve(options.projectRoot, file), 'utf8'));
+        }
+        await recompileAfterWrite();
+        return {
+            type: 'suspect:review:result',
+            payload: { requestId, success: true, reviewed: reviews.map(r => r.relationship.id), sourceFiles: result.sourceFiles },
+        };
+    }
     /** Move relationship endpoints as one source edit, including anonymous flows. */
     async function handleRelationshipUpdate(payload) {
         const requestId = payload?.requestId ?? '';
@@ -867,7 +1038,7 @@ export async function createDevServer(options) {
             const first = validation.diagnostics.find(diagnostic => diagnostic.severity === 'error');
             return reject(first?.message ?? 'The relationship update is not valid.', validation.diagnostics);
         }
-        const result = await updateRelationship(payload, relationship, validation.definition, model, relationshipWriterOptions());
+        const result = await updateRelationship(payload, relationship, validation.definition, model, await relationshipWriterOptions());
         if (!result.success)
             return reject(result.error ?? 'The relationship could not be updated.');
         if (result.sourceFile) {
@@ -922,7 +1093,7 @@ export async function createDevServer(options) {
             if (parent && !fileOf(parent)) {
                 return { success: false, filePaths: [], error: `Package "${parent}" was not found.` };
             }
-            return createPackage(projectRoot, { file, parent, name: String(payload.name ?? '') });
+            return createPackage(projectRoot, { file, parent, name: String(payload.name ?? '') }, (await authoringContext()).outlines);
         }
         const qualifiedName = String(payload.qualifiedName ?? '');
         if (type === 'package:rename' || type === 'package:delete' || type === 'package:move') {
@@ -930,16 +1101,16 @@ export async function createDevServer(options) {
             if (!file)
                 return { success: false, filePaths: [], error: `Package "${qualifiedName}" was not found.` };
             if (type === 'package:rename') {
-                return renamePackage(projectRoot, { file, qualifiedName, name: String(payload.name ?? '') });
+                return renamePackage(projectRoot, { file, qualifiedName, name: String(payload.name ?? '') }, (await authoringContext()).outlines);
             }
             if (type === 'package:delete')
-                return deletePackage(projectRoot, { file, qualifiedName });
+                return deletePackage(projectRoot, { file, qualifiedName }, (await authoringContext()).outlines);
             const targetParent = payload.targetParent || undefined;
             const targetFile = targetParent ? fileOf(targetParent) : file;
             if (targetParent && !targetFile) {
                 return { success: false, filePaths: [], error: `Package "${targetParent}" was not found.` };
             }
-            return movePackage(projectRoot, { file, qualifiedName, targetParent, targetFile: targetFile });
+            return movePackage(projectRoot, { file, qualifiedName, targetParent, targetFile: targetFile }, (await authoringContext()).outlines);
         }
         const elementId = String(payload.elementId ?? '');
         const element = model.elements[elementId];
@@ -978,7 +1149,7 @@ export async function createDevServer(options) {
                 file: element.file,
                 qualifiedName: declarationPath(element),
                 targetPackage,
-            });
+            }, (await authoringContext()).outlines);
         }
         const irIdentity = irIndex().byMemoElement[elementId];
         if (!irIdentity) {
@@ -989,7 +1160,7 @@ export async function createDevServer(options) {
         }
         return moveElementToPackage(projectRoot, {
             elementId, irIdentity, sourceFile: element.file, targetFile: targetFile, targetPackage,
-        }, irIndex());
+        }, irIndex(), (await authoringContext()).outlines);
     }
     async function handleElementDelete(payload) {
         const requestId = payload?.requestId ?? '';
@@ -1010,7 +1181,7 @@ export async function createDevServer(options) {
         if (element.provenance && !element.provenance.declaration.writable) {
             return reject(`Element "${elementId}" is read-only ${element.provenance.declaration.origin} content.`);
         }
-        const result = await removeElement(element, model, options.projectRoot);
+        const result = await removeElement(element, model, options.projectRoot, (await authoringContext()).outlines);
         if (result.success) {
             for (const sourceFile of result.sourceFiles ?? []) {
                 const path = resolve(options.projectRoot, sourceFile);
@@ -1081,19 +1252,35 @@ export async function createDevServer(options) {
      * granularity is too coarse to trust for conflict detection.
      */
     function fileRevision(contents) {
+        // Layout-blind: a box moved on a canvas is not an edit of the file. For a
+        // targeted edit, which is computed again from the file as it is.
+        return layoutBlindRevision(contents);
+    }
+    /**
+     * The revision of a whole file's text, layout included. A save that replaces
+     * the file with text an editor loaded earlier must not pass when a layout was
+     * written into the file since: it would put the old statements back.
+     */
+    function textRevision(contents) {
         return createHash('sha256').update(contents).digest('hex').slice(0, 16);
     }
-    /** Parse errors in SysML text, so the editor can show them without a rebuild. */
-    async function sysmlParseErrors(text) {
+    /**
+     * What the selected compiler says about SysML text, so the editor can show
+     * it without waiting for the rebuild. The write already stands, so a
+     * compiler that cannot be reached is not a save failure.
+     */
+    async function sysmlParseErrors(file, text) {
         try {
-            const { parseText } = await import('../model/parser-utils.js');
-            const { errors } = await parseText(text);
-            return errors.slice(0, 10).map(error => typeof error.line === 'number' ? `Line ${error.line}: ${error.message}` : error.message);
-        }
-        catch {
-            // A parser failure is not a save failure — the write already stands.
+            const { loadAndResolveConfig } = await import('./config-resolver.js');
+            const { findConfigFile, loadProjectSettings } = await import('@memoarchitect/tools');
+            const configPath = findConfigFile(options.projectRoot);
+            const config = configPath ? loadAndResolveConfig(configPath) : loadProjectSettings(options.projectRoot);
+            await selectedOutlineSource(options.projectRoot, config).verify(file, text);
             return [];
         }
+        catch (error) {
+            return [(error instanceof Error ? error.message : String(error))];
+        }
     }
     /** Resolve only the project-local .sysml source declared by the diagram. */
     function diagramSource(diagramId) {
@@ -1130,10 +1317,28 @@ export async function createDevServer(options) {
         if (sourceIncoherence)
             ws.send(JSON.stringify(sourceIncoherence));
         // Send all sidecar layouts on connect
-        const layouts = loadViewLayouts(options.projectRoot, currentDiagrams());
+        const layouts = loadViewLayouts(options.projectRoot, currentDiagrams(), savedId => {
+            const model = currentModel();
+            if (!model || model.elements[savedId])
+                return undefined;
+            // A layout written before ids were qualified keys its nodes by the
+            // declared name. Accept it when exactly one element answers to it.
+            const matches = Object.keys(model.elements)
+                .filter(id => (model.elements[id].shortName ?? id) === savedId);
+            return matches.length === 1 ? matches[0] : undefined;
+        });
         if (Object.keys(layouts).length > 0) {
             ws.send(JSON.stringify({ type: 'diagram:layout', payload: { layouts } }));
         }
+        // The person's own choices for this model (memo.user.yaml)
+        try {
+            ws.send(JSON.stringify({ type: 'user-preferences', payload: loadUserPreferences(options.preferencesRoot ?? options.projectRoot) }));
+            if (options.readOnly)
+                ws.send(JSON.stringify({ type: 'pinned:info', payload: options.pinned ?? { kind: 'read-only', label: 'read-only' } }));
+        }
+        catch (e) {
+            console.error('[Preferences] load failed:', e);
+        }
         // Send custom dashboards on connect
         try {
             ws.send(JSON.stringify({ type: 'dashboards', payload: { dashboards: loadDashboards(options.projectRoot) } }));
@@ -1153,6 +1358,15 @@ export async function createDevServer(options) {
         catch (e) {
             console.error('[DHF] initial load failed:', e);
         }
+        // The user's own toolchain settings: shown in Architect, written to their file.
+        void (async () => {
+            try {
+                ws.send(JSON.stringify({ type: 'toolchain:settings', payload: { settings: await toolchainSettings() } }));
+            }
+            catch (e) {
+                console.error('[toolchain] settings load failed:', e);
+            }
+        })();
         // Announce LLM availability and settings on connect. Resolution spans
         // the environment, a project .env, project settings and stored
         // credentials — never just process.env.
@@ -1173,9 +1387,20 @@ export async function createDevServer(options) {
             clients.delete(ws);
             options.onClientCountChanged?.(clients.size);
         });
-        ws.on('message', async (data) => {
+        const handleMessage = async (data) => {
             try {
                 const msg = JSON.parse(data.toString());
+                if (options.readOnly && !isReadOnlyMessage(msg.type)) {
+                    // Refused by name, not by what it would have written: see READ_ONLY_MESSAGES.
+                    ws.send(JSON.stringify({
+                        type: 'app:error',
+                        payload: {
+                            requestId: msg.payload?.requestId,
+                            error: 'This is a pinned, read-only view; nothing can be changed in it. Open the working version to edit.',
+                        },
+                    }));
+                    return;
+                }
                 if (mutationLockout && isModelMutationMessage(msg.type)) {
                     // A section 13.5 escalation is a hard server boundary;
                     // stale and hand-authored clients cannot write through it.
@@ -1278,7 +1503,7 @@ export async function createDevServer(options) {
                     if (result.success) {
                         transactionId = recordWriteTransaction(result.filePath, readFileSync(resolve(projectRoot, result.filePath), 'utf8'));
                         if (result.revision)
-                            writeBackIndex = result.revision.index;
+                            writeBackIndex = addressable(result.revision.index);
                         console.log(`[Persisted] ${msg.type} to ${result.filePath}`);
                     }
                     if (result.stale) {
@@ -1393,10 +1618,10 @@ export async function createDevServer(options) {
                     const diagram = { ...msg.payload, auto: false };
                     // A view is model content, so it is DECLARED, not recorded in
                     // a sidecar. Writing the SysML puts it where `memo validate`,
-                    // `syside check`, review and git can all see it, and — the
-                    // derived diagram then carrying a `sourceFile` — takes its
-                    // `.viewlayout` companion out of the hidden store too.
-                    const declared = await writeViewDeclaration(projectRoot, currentModel() ?? { elements: {}, diagrams: [] }, diagram);
+                    // the selected compiler, review and git can all see it, and — the
+                    // derived diagram then carrying a `sourceFile` — has a place to keep
+                    // its layout.
+                    const declared = await writeViewDeclaration(projectRoot, currentModel() ?? { elements: {}, diagrams: [] }, diagram, (await authoringContext()).outlines);
                     if (!declared.success) {
                         // No fallback. A view that cannot be declared is not one
                         // this project can hold, and recording it in a sidecar
@@ -1422,7 +1647,7 @@ export async function createDevServer(options) {
                     const { projectRoot } = options;
                     const declared = currentDiagrams().find(d => d.id === msg.payload?.id);
                     const result = declared
-                        ? await updateViewExpose(projectRoot, currentModel() ?? { elements: {} }, declared, msg.payload?.elementIds)
+                        ? await updateViewExpose(projectRoot, currentModel() ?? { elements: {} }, declared, msg.payload?.elementIds, (await authoringContext()).outlines)
                         : { success: false, reason: `no view "${msg.payload?.id}" is declared` };
                     if (result.success) {
                         console.log(`[Diagram] Exposed ${result.exposed.join(', ')} on ${declared.name} (${result.filePath})`);
@@ -1434,6 +1659,22 @@ export async function createDevServer(options) {
                         ws.send(JSON.stringify({ type: 'app:error', payload: { requestId: msg.payload?.requestId, error } }));
                     }
                 }
+                else if (msg.type === 'diagram:display:update') {
+                    const { projectRoot } = options;
+                    const declared = currentDiagrams().find(d => d.id === msg.payload?.diagramId);
+                    const result = declared
+                        ? await updateViewDisplay(projectRoot, currentModel() ?? { elements: {} }, declared, msg.payload?.display ?? {}, (await authoringContext()).outlines)
+                        : { success: false, reason: `no view "${msg.payload?.diagramId}" is declared` };
+                    if (result.success) {
+                        await recompileAfterWrite();
+                    }
+                    else {
+                        ws.send(JSON.stringify({ type: 'app:error', payload: {
+                                requestId: msg.payload?.requestId,
+                                error: `How "${declared?.name ?? msg.payload?.diagramId}" is shown was not saved: ${result.reason}.`,
+                            } }));
+                    }
+                }
                 else if (msg.type === 'diagram:delete') {
                     // Deleting a view means deleting its declaration, which is
                     // `element:delete` on the view element — not a sidecar edit.
@@ -1448,12 +1689,32 @@ export async function createDevServer(options) {
                 }
                 else if (msg.type === 'diagram:layout:update') {
                     const { diagramId, layout } = msg.payload;
-                    const diagram = currentDiagrams().find(d => d.id === diagramId)
-                        ?? { id: diagramId, name: diagramId, diagramType: 'bdd', viewpointId: '__model', auto: false };
-                    const savedPath = saveViewLayout(options.projectRoot, diagram, layout);
-                    console.log(savedPath
-                        ? `[Diagram] Saved layout: ${savedPath}`
-                        : `[Diagram] No overrides to save for ${diagramId}`);
+                    const diagram = currentDiagrams().find(d => d.id === diagramId);
+                    // The layout is written into the `view` that declares the
+                    // diagram, and nowhere else. A diagram that is not a declared
+                    // view keeps its layout for the session only.
+                    const saved = diagram
+                        ? await saveViewLayout(options.projectRoot, diagram, layout, (await authoringContext()).outlines)
+                        : { success: false, reason: `no view "${diagramId}" is declared` };
+                    if (!saved.success) {
+                        console.log(`[Diagram] Layout of ${diagramId} not saved: ${saved.reason}`);
+                        // Said to the sender, who is showing a layout the file does not hold.
+                        ws.send(JSON.stringify({ type: 'app:error', payload: {
+                                requestId: msg.payload?.requestId,
+                                error: `The layout of "${diagram?.name ?? diagramId}" was not saved: ${saved.reason}.`,
+                            } }));
+                        return;
+                    }
+                    else if ('changed' in saved && saved.changed && saved.filePath) {
+                        console.log(`[Diagram] Saved layout: ${saved.filePath}`);
+                        // The file watcher sees this write, finds it layout-only and
+                        // does not rebuild; the write is matched here so it is not
+                        // mistaken for an outside edit.
+                        recordWriteTransaction(saved.filePath, readFileSync(resolve(options.projectRoot, saved.filePath), 'utf8'));
+                    }
+                    else {
+                        console.log(`[Diagram] No change to the layout of ${diagramId}`);
+                    }
                     // Broadcast to other clients (not the sender)
                     const layoutMsg = JSON.stringify({ type: 'diagram:layout', payload: { layouts: { [diagramId]: layout } } });
                     for (const client of clients) {
@@ -1464,12 +1725,21 @@ export async function createDevServer(options) {
                 else if (msg.type === 'relationship:create') {
                     ws.send(JSON.stringify(await handleRelationshipCreate(msg.payload)));
                 }
+                else if (msg.type === 'release:create') {
+                    ws.send(JSON.stringify(await handleReleaseCreate(msg.payload)));
+                }
                 else if (msg.type === 'relationship:delete') {
                     ws.send(JSON.stringify(await handleRelationshipDelete(msg.payload)));
                 }
                 else if (msg.type === 'relationship:update') {
                     ws.send(JSON.stringify(await handleRelationshipUpdate(msg.payload)));
                 }
+                else if (msg.type === 'import:preview' || msg.type === 'import:apply') {
+                    ws.send(JSON.stringify(await handleSourceImport(msg.type === 'import:preview' ? 'preview' : 'apply', msg.payload)));
+                }
+                else if (msg.type === 'suspect:review') {
+                    ws.send(JSON.stringify(await handleSuspectReview(msg.payload)));
+                }
                 else if (msg.type === 'element:delete') {
                     ws.send(JSON.stringify(await handleElementDelete(msg.payload)));
                 }
@@ -1484,10 +1754,11 @@ export async function createDevServer(options) {
                         const elements = modelMsg?.payload?.elements ?? {};
                         const { saveElementToFile } = await import('./persistor.js');
                         let remappedCount = 0;
+                        const remapOutlines = (await authoringContext()).outlines;
                         for (const element of Object.values(elements)) {
                             const newKind = mappings[element.kind];
                             if (newKind) {
-                                const result = await saveElementToFile(projectRoot, { ...element, kind: newKind }, irIndex());
+                                const result = await saveElementToFile(projectRoot, { ...element, kind: newKind }, irIndex(), remapOutlines);
                                 if (result.success)
                                     remappedCount++;
                             }
@@ -1558,7 +1829,7 @@ export async function createDevServer(options) {
                             throw new Error('The requested file is not in the resolved methodology source set.');
                         }
                         const onDisk = readFileSync(path, 'utf8');
-                        const revision = fileRevision(onDisk);
+                        const revision = textRevision(onDisk);
                         if (operation === 'load') {
                             reply({ success: true, text: onDisk, revision });
                             return;
@@ -1585,7 +1856,7 @@ export async function createDevServer(options) {
                         }
                         writeFileSync(path, text, 'utf8');
                         const transactionId = recordWriteTransaction(String(sourceFile), text);
-                        reply({ success: true, revision: fileRevision(text), transactionId });
+                        reply({ success: true, revision: textRevision(text), transactionId });
                     }
                     catch (error) {
                         reply({ success: false, error: error instanceof Error ? error.message : String(error) });
@@ -1616,7 +1887,7 @@ export async function createDevServer(options) {
                             throw new Error('The target file is not in the resolved methodology source set.');
                         }
                         const onDisk = readFileSync(path, 'utf8');
-                        const revision = fileRevision(onDisk);
+                        const revision = textRevision(onDisk);
                         if (request.baseRevision !== revision) {
                             reply({ success: false, conflict: true, revision,
                                 error: `${request.sourceFile} changed on disk; no write was made.` });
@@ -1624,11 +1895,43 @@ export async function createDevServer(options) {
                         }
                         const updated = insertRulePolicy(onDisk, renderRulePolicy(request));
                         if (!updated) {
-                            throw new Error(`${request.sourceFile} declares no MethodologyDefinition to attach the policy to.`);
+                            throw new Error(`${request.sourceFile} declares no ModelMethodBinding or MethodologyDefinition to attach the policy to.`);
                         }
                         writeFileSync(path, updated, 'utf8');
                         const transactionId = recordWriteTransaction(String(request.sourceFile), updated);
-                        reply({ success: true, revision: fileRevision(updated), transactionId });
+                        reply({ success: true, revision: textRevision(updated), transactionId });
+                    }
+                    catch (error) {
+                        reply({ success: false, error: error instanceof Error ? error.message : String(error) });
+                    }
+                }
+                else if (msg.type === 'rule:preview' || msg.type === 'rule:create') {
+                    // A rule of the user's. Preview and write take the same
+                    // request through the same checks (rule-service.ts); the
+                    // browser names the rule and Tools renders and verifies it.
+                    const { requestId } = msg.payload ?? {};
+                    const resultType = msg.type === 'rule:preview' ? 'rule:preview:result' : 'rule:create:result';
+                    const reply = (payload) => ws.send(JSON.stringify({ type: resultType, payload: { requestId, ...payload } }));
+                    try {
+                        const context = options.ruleContext?.();
+                        if (!context) {
+                            reply({ success: false, error: 'The project has not built yet, so a rule cannot be checked against it.' });
+                            return;
+                        }
+                        const form = msg.payload;
+                        if (msg.type === 'rule:preview') {
+                            reply(previewRule(context, form));
+                        }
+                        else {
+                            const written = await createRule(context, form);
+                            if (written.success) {
+                                const transactionId = recordWriteTransaction(String(form.file), written.text);
+                                reply({ success: true, revision: written.revision, transactionId });
+                            }
+                            else {
+                                reply(written);
+                            }
+                        }
                     }
                     catch (error) {
                         reply({ success: false, error: error instanceof Error ? error.message : String(error) });
@@ -1643,7 +1946,7 @@ export async function createDevServer(options) {
                             type: 'diagram:source:result',
                             payload: {
                                 requestId, diagramId, operation: 'load', success: true,
-                                sourceFile: source.sourceFile, text, revision: fileRevision(text),
+                                sourceFile: source.sourceFile, text, revision: textRevision(text),
                             },
                         }));
                     }
@@ -1666,7 +1969,7 @@ export async function createDevServer(options) {
                         // began. The client gets the current file back so it can
                         // show the conflict instead of losing one of the two.
                         const onDisk = readFileSync(source.path, 'utf8');
-                        const currentRevision = fileRevision(onDisk);
+                        const currentRevision = textRevision(onDisk);
                         if (baseRevision !== currentRevision) {
                             console.warn(`[Diagram] Refused stale save of ${source.sourceFile} ` +
                                 `(based on ${baseRevision}, disk is ${currentRevision})`);
@@ -1690,15 +1993,16 @@ export async function createDevServer(options) {
                             }));
                             return;
                         }
+                        assertWritable(source.path);
                         writeFileSync(source.path, text, 'utf8');
                         const transactionId = recordWriteTransaction(source.sourceFile, text);
                         ws.send(JSON.stringify({
                             type: 'diagram:source:result',
                             payload: {
                                 requestId, diagramId, operation: 'save', success: true,
-                                sourceFile: source.sourceFile, revision: fileRevision(text),
+                                sourceFile: source.sourceFile, revision: textRevision(text),
                                 transactionId,
-                                parseErrors: await sysmlParseErrors(text),
+                                parseErrors: await sysmlParseErrors(source.sourceFile, text),
                             },
                         }));
                         // The project watcher rebuilds and broadcasts the resulting model.
@@ -1823,8 +2127,9 @@ export async function createDevServer(options) {
                                 }
                             }
                             // Refresh packages and broadcast
-                            const { getPackageMetadata } = await import('@memoarchitect/tools');
-                            const packages = getPackageMetadata(projectRoot);
+                            // The list is read from the last build's handoff: a package just
+                            // installed joins it when the project next compiles.
+                            const packages = options.packageMetadata?.() ?? [];
                             const pkgMsg = { type: 'ontology:packages', payload: { packages } };
                             for (const client of clients) {
                                 if (client.readyState === 1)
@@ -1851,7 +2156,7 @@ export async function createDevServer(options) {
                     const { projectRoot } = options;
                     const { elementsCsv, relationshipsCsv, packageName, targetFile } = msg.payload ?? {};
                     try {
-                        const { parseElementsCsv, parseRelationshipsCsv, generateFile, attachProvenance, loadProjectSettings, } = await import('@memoarchitect/tools');
+                        const { parseElementsCsv, parseRelationshipsCsv, generateFile, loadProjectSettings, } = await import('@memoarchitect/tools');
                         const config = loadProjectSettings(projectRoot);
                         const { ontology } = await llmQueryContext();
                         const errors = [];
@@ -1864,13 +2169,7 @@ export async function createDevServer(options) {
                             const result = parseElementsCsv(elementsCsv, ontology);
                             errors.push(...result.errors);
                             warnings.push(...result.warnings);
-                            // Attach provenance
-                            const sessionId = `ws-${Date.now().toString(36)}`;
-                            elements = attachProvenance(result.items, {
-                                sourceFile: targetFile ?? 'web-import',
-                                importTimestamp: new Date().toISOString(),
-                                importSessionId: sessionId,
-                            });
+                            elements = result.items;
                             elementsImported = elements.length;
                         }
                         if (relationshipsCsv) {
@@ -1914,7 +2213,7 @@ export async function createDevServer(options) {
                     const { requestId, question } = msg.payload ?? {};
                     try {
                         const { resolveLLMConfig, createProvider } = await import('@memoarchitect/tools');
-                        const { createQueryContext, findConfigFile } = await import('@memoarchitect/tools');
+                        const { findConfigFile } = await import('@memoarchitect/tools');
                         const { askModel } = await import('@memoarchitect/tools');
                         const { loadAndResolveConfig } = await import('./config-resolver.js');
                         const llmConfig = resolveLLMConfig();
@@ -1927,7 +2226,7 @@ export async function createDevServer(options) {
                             const compMsg = initialMessages.find((m) => m.type === 'completeness:update');
                             const configPath = findConfigFile(options.projectRoot);
                             const config = configPath ? await loadAndResolveConfig(configPath) : {};
-                            const ctx = createQueryContext(modelMsg?.payload ?? {}, validMsg?.payload ?? { violations: [] }, compMsg?.payload ?? { overall: 0, layers: [] }, config);
+                            const ctx = await scopedQueryContext(config, msg.payload?.workspace);
                             const provider = createProvider(llmConfig);
                             const result = await askModel(question, ctx, provider);
                             ws.send(JSON.stringify({ type: 'llm:ask:result', payload: { requestId, answer: result.answer } }));
@@ -1948,7 +2247,7 @@ export async function createDevServer(options) {
                             ws.send(JSON.stringify({ type: 'llm:chat:result', payload: { requestId, error: 'No LLM provider configured. Add an API key in Settings, set ANTHROPIC_API_KEY or OPENAI_API_KEY, or put one in a project .env file.' } }));
                         }
                         else {
-                            const { ctx, ontology } = await llmQueryContext();
+                            const { ctx, ontology } = await llmQueryContext(msg.payload?.workspace);
                             const provider = createProvider(llmConfig);
                             const result = await runChatTurn({
                                 question, history, ctx, provider, ontology,
@@ -1996,6 +2295,31 @@ export async function createDevServer(options) {
                         ws.send(JSON.stringify({ type: 'llm:chat:apply:result', payload: { requestId, applied, failed, error: e?.message ?? String(e) } }));
                     }
                 }
+                else if (msg.type === 'toolchain:settings:save') {
+                    // Not a model mutation: it writes the user's own file, and is how a
+                    // user gets out of a compiler that rejects their project.
+                    const { requestId, path, value, scope } = msg.payload ?? {};
+                    try {
+                        const { applyUserSetting, applyProjectSetting } = await import('../toolchain/user-settings-status.js');
+                        const { defaultRegistry } = await import('../toolchain/default-registry.js');
+                        const wanted = typeof value === 'string' && value.length > 0 ? value : undefined;
+                        // The project's own file is watched: the change reaches the restart-required flow by itself.
+                        if (scope === 'project')
+                            applyProjectSetting(options.projectRoot, String(path ?? ''), wanted, defaultRegistry);
+                        else
+                            applyUserSetting(String(path ?? ''), wanted, defaultRegistry);
+                        const settings = await toolchainSettings();
+                        ws.send(JSON.stringify({ type: 'toolchain:settings:save:result', payload: { requestId, settings, appliesOnRestart: true } }));
+                        const settingsMsg = JSON.stringify({ type: 'toolchain:settings', payload: { settings } });
+                        for (const client of clients) {
+                            if (client.readyState === 1)
+                                client.send(settingsMsg);
+                        }
+                    }
+                    catch (e) {
+                        ws.send(JSON.stringify({ type: 'toolchain:settings:save:result', payload: { requestId, error: e?.message ?? String(e) } }));
+                    }
+                }
                 else if (msg.type === 'llm:settings:save') {
                     const { requestId, provider, model, baseUrl, apiKey } = msg.payload ?? {};
                     try {
@@ -2047,7 +2371,7 @@ export async function createDevServer(options) {
                     // Draft DHF document sections via LLM (#55)
                     const { requestId, documentTypeId, targetSections } = msg.payload ?? {};
                     try {
-                        const { resolveLLMConfig, createProvider, createQueryContext, findConfigFile, getDocumentType } = await import('@memoarchitect/tools');
+                        const { resolveLLMConfig, createProvider, findConfigFile, getDocumentType } = await import('@memoarchitect/tools');
                         const { draftDocument } = await import('@memoarchitect/tools');
                         const { loadAndResolveConfig } = await import('./config-resolver.js');
                         const llmConfig = resolveLLMConfig();
@@ -2060,7 +2384,7 @@ export async function createDevServer(options) {
                             const compMsg = initialMessages.find((m) => m.type === 'completeness:update');
                             const configPath = findConfigFile(options.projectRoot);
                             const config = configPath ? await loadAndResolveConfig(configPath) : {};
-                            const ctx = createQueryContext(modelMsg?.payload ?? {}, validMsg?.payload ?? { violations: [] }, compMsg?.payload ?? { overall: 0, layers: [] }, config);
+                            const ctx = await scopedQueryContext(config, msg.payload?.workspace);
                             const docType = getDocumentType(documentTypeId);
                             if (!docType) {
                                 ws.send(JSON.stringify({ type: 'llm:draft:result', payload: { requestId, error: `Unknown document type: ${documentTypeId}` } }));
@@ -2090,7 +2414,7 @@ export async function createDevServer(options) {
                     // Completeness suggestions via LLM (#53)
                     const { requestId } = msg.payload ?? {};
                     try {
-                        const { resolveLLMConfig, createProvider, createQueryContext, findConfigFile, serializeModelContext } = await import('@memoarchitect/tools');
+                        const { resolveLLMConfig, createProvider, findConfigFile, serializeModelContext } = await import('@memoarchitect/tools');
                         const { loadAndResolveConfig } = await import('./config-resolver.js');
                         const llmConfig = resolveLLMConfig();
                         if (!llmConfig) {
@@ -2102,7 +2426,7 @@ export async function createDevServer(options) {
                             const compMsg = initialMessages.find((m) => m.type === 'completeness:update');
                             const configPath = findConfigFile(options.projectRoot);
                             const config = configPath ? await loadAndResolveConfig(configPath) : {};
-                            const ctx = createQueryContext(modelMsg?.payload ?? {}, validMsg?.payload ?? { violations: [] }, compMsg?.payload ?? { overall: 0, layers: [] }, config);
+                            const ctx = await scopedQueryContext(config, msg.payload?.workspace);
                             const modelContext = serializeModelContext(ctx, { includeGaps: true, maxElements: 200 });
                             const provider = createProvider(llmConfig);
                             const result = await provider.complete({
@@ -2139,6 +2463,69 @@ Return ONLY a JSON array of strings. Each string is a concise, actionable sugges
                         ws.send(JSON.stringify({ type: 'llm:suggest:result', payload: { requestId, error: e?.message ?? String(e) } }));
                     }
                 }
+                else if (msg.type === 'versions:list') {
+                    // The unreleased refs; the releases are read from the model the client already has.
+                    const refs = options.versions ? await options.versions.refs() : [];
+                    ws.send(JSON.stringify({ type: 'versions:update', payload: { refs } }));
+                }
+                else if (msg.type === 'version:open') {
+                    const requestId = msg.payload?.requestId;
+                    try {
+                        if (!options.versions)
+                            throw new Error('A pinned view is opened from the working version; open that one first.');
+                        const opened = await options.versions.open({ release: msg.payload?.release, ref: msg.payload?.ref });
+                        ws.send(JSON.stringify({ type: 'version:ready', payload: { requestId, ...opened } }));
+                    }
+                    catch (e) {
+                        ws.send(JSON.stringify({ type: 'version:error', payload: { requestId, error: e?.message ?? String(e) } }));
+                    }
+                }
+                else if (msg.type === 'impact:compute') {
+                    const requestId = msg.payload?.requestId;
+                    try {
+                        if (!options.impact)
+                            throw new Error('Impact is computed from the working version.');
+                        ws.send(JSON.stringify({ type: 'impact:result', payload: { requestId, report: await options.impact.compute(msg.payload?.target || undefined) } }));
+                    }
+                    catch (e) {
+                        ws.send(JSON.stringify({ type: 'impact:result', payload: { requestId, error: e?.message ?? String(e) } }));
+                    }
+                }
+                else if (msg.type === 'guide:evaluate') {
+                    const requestId = msg.payload?.requestId;
+                    try {
+                        if (!options.guide)
+                            throw new Error('The Guide is not available here.');
+                        ws.send(JSON.stringify({ type: 'guide:result', payload: { requestId, ...options.guide.evaluate(msg.payload?.workspace || undefined) } }));
+                    }
+                    catch (e) {
+                        ws.send(JSON.stringify({ type: 'guide:result', payload: { requestId, steps: [], methodologies: [], roleViews: [], error: e?.message ?? String(e) } }));
+                    }
+                }
+                else if (msg.type === 'dhf:device:generate') {
+                    const requestId = msg.payload?.requestId;
+                    try {
+                        if (!options.devices)
+                            throw new Error('Documents are generated from the working version.');
+                        const result = await options.devices.generate(String(msg.payload?.device ?? ''));
+                        ws.send(JSON.stringify({ type: 'dhf:device:result', payload: { requestId, success: true, ...result } }));
+                    }
+                    catch (e) {
+                        ws.send(JSON.stringify({ type: 'dhf:device:result', payload: { requestId, success: false, error: e?.message ?? String(e) } }));
+                    }
+                }
+                else if (msg.type === 'release:diff') {
+                    const requestId = msg.payload?.requestId;
+                    try {
+                        if (!options.versions)
+                            throw new Error('Releases are compared from the working version.');
+                        const result = await options.versions.diff(String(msg.payload?.release ?? ''), String(msg.payload?.against ?? 'previous'));
+                        ws.send(JSON.stringify({ type: 'release:diff:result', payload: { requestId, ...result } }));
+                    }
+                    catch (e) {
+                        ws.send(JSON.stringify({ type: 'release:diff:result', payload: { requestId, error: e?.message ?? String(e) } }));
+                    }
+                }
                 else if (msg.type === 'dashboard:save' || msg.type === 'dashboard:delete' || msg.type === 'dashboard:move') {
                     // Dashboards are presentation, not model source: they are
                     // deliberately absent from MODEL_MUTATION_MESSAGES, so a
@@ -2163,6 +2550,17 @@ Return ONLY a JSON array of strings. Each string is a concise, actionable sugges
                         ws.send(JSON.stringify({ type: 'dashboard:result', payload: { requestId: p.requestId, ok: false, error: e?.message ?? String(e) } }));
                     }
                 }
+                else if (msg.type === 'user-preferences:save') {
+                    // Not model source either: one person's choice, written to a
+                    // git-ignored file, and only that person's clients hear it.
+                    try {
+                        const saved = saveUserPreferences(options.projectRoot, msg.payload ?? {});
+                        ws.send(JSON.stringify({ type: 'user-preferences', payload: saved }));
+                    }
+                    catch (e) {
+                        console.error('[Preferences] save failed:', e);
+                    }
+                }
                 else if (msg.type === 'dhf:docs:load') {
                     const docs = loadDhfDocs(options.projectRoot);
                     ws.send(JSON.stringify({ type: 'dhf:docs', payload: { docs } }));
@@ -2236,8 +2634,7 @@ Return ONLY a JSON array of strings. Each string is a concise, actionable sugges
                                 rmSync(memoPkgsPath, { recursive: true, force: true });
                             }
                             // Refresh and broadcast
-                            const { getPackageMetadata } = await import('@memoarchitect/tools');
-                            const packages = getPackageMetadata(projectRoot);
+                            const packages = options.packageMetadata?.() ?? [];
                             const pkgMsg = { type: 'ontology:packages', payload: { packages } };
                             for (const client of clients) {
                                 if (client.readyState === 1)
@@ -2262,6 +2659,32 @@ Return ONLY a JSON array of strings. Each string is a concise, actionable sugges
             catch (e) {
                 console.error('WebSocket Error:', e);
             }
+        };
+        // Every write is made from a read of the file it writes, with the compiler
+        // between the two, so two writes in flight would each start from the text
+        // before the other and one would be lost. They run one at a time, in the
+        // order they arrived. A layout message names the whole layout of its
+        // diagram, so one that a newer message for the same diagram has overtaken
+        // is dropped rather than written.
+        ws.on('message', (data) => {
+            let type;
+            let layoutOf;
+            try {
+                const parsed = JSON.parse(data.toString());
+                type = parsed?.type;
+                if (type === 'diagram:layout:update')
+                    layoutOf = String(parsed?.payload?.diagramId);
+            }
+            catch { /* the handler reports a message that does not parse */ }
+            if (!type || !isModelMutationMessage(type)) {
+                void handleMessage(data);
+                return;
+            }
+            const seq = layoutOf === undefined ? 0 : (latestLayoutMessage.get(layoutOf) ?? 0) + 1;
+            if (layoutOf !== undefined)
+                latestLayoutMessage.set(layoutOf, seq);
+            const run = mutationQueue.then(() => layoutOf !== undefined && latestLayoutMessage.get(layoutOf) !== seq ? undefined : handleMessage(data));
+            mutationQueue = run.then(() => undefined, () => undefined);
         });
     });
     // Start listening
@@ -2297,6 +2720,21 @@ Return ONLY a JSON array of strings. Each string is a concise, actionable sugges
                 }
             }
         },
+        refreshLayouts(files) {
+            const wanted = new Set(files.map(file => file.replaceAll('\\', '/')));
+            const diagrams = currentDiagrams().filter(d => d.sourceFile && wanted.has(d.sourceFile.replaceAll('\\', '/')));
+            const layouts = loadViewLayouts(options.projectRoot, diagrams);
+            // A diagram whose statements are all gone is sent as an empty layout,
+            // or the clients would keep the one they had.
+            for (const diagram of diagrams)
+                layouts[diagram.id] ??= { nodes: {}, edges: {} };
+            if (Object.keys(layouts).length === 0)
+                return;
+            const message = JSON.stringify({ type: 'diagram:layout', payload: { layouts } });
+            for (const client of clients)
+                if (client.readyState === 1)
+                    client.send(message);
+        },
         consumeWriteTransactions(files) {
             const matched = {};
             let escalationFile;
@@ -2350,4 +2788,15 @@ Return ONLY a JSON array of strings. Each string is a concise, actionable sugges
         },
     };
 }
+/** A port nothing is listening on, for a socket that must not collide with another server's. */
+function freePort(host) {
+    return new Promise((resolvePort, reject) => {
+        const probe = createNetServer();
+        probe.once('error', reject);
+        probe.listen(0, typeof host === 'string' ? host : undefined, () => {
+            const { port } = probe.address();
+            probe.close(() => resolvePort(port));
+        });
+    });
+}
 //# sourceMappingURL=dev-server.js.map