orbital-command 0.2.0 → 1.0.0

package/dist/server/server/services/sync-service.js

@@ -0,0 +1,434 @@
+import path from 'path';
+import fs from 'fs';
+import { GLOBAL_PRIMITIVES_DIR, GLOBAL_WORKFLOW_PATH, getRegisteredProjects } from '../global-config.js';
+import { createLogger } from '../utils/logger.js';
+import { hashFile, hashTree } from '../manifest.js';
+const log = createLogger('sync');
+const SYNC_MANIFEST_FILENAME = 'orbital-sync.json';
+// ─── Manifest I/O ───────────────────────────────────────────
+function manifestPath(projectRoot) {
+    return path.join(projectRoot, '.claude', SYNC_MANIFEST_FILENAME);
+}
+/** Load a project's sync manifest, or return null if none exists. */
+function loadManifest(projectRoot) {
+    const mp = manifestPath(projectRoot);
+    if (!fs.existsSync(mp))
+        return null;
+    try {
+        return JSON.parse(fs.readFileSync(mp, 'utf-8'));
+    }
+    catch {
+        log.warn('Failed to parse sync manifest', { path: mp });
+        return null;
+    }
+}
+/** Save a project's sync manifest atomically. */
+function saveManifest(projectRoot, manifest) {
+    const mp = manifestPath(projectRoot);
+    const dir = path.dirname(mp);
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+    const tmp = mp + '.tmp';
+    try {
+        fs.writeFileSync(tmp, JSON.stringify(manifest, null, 2), 'utf-8');
+        fs.renameSync(tmp, mp);
+    }
+    catch (err) {
+        try {
+            fs.unlinkSync(tmp);
+        }
+        catch { /* best-effort cleanup */ }
+        throw err;
+    }
+}
+/** Create a default manifest for a project by comparing its files against global. */
+function createInitialManifest(projectRoot) {
+    const claudeDir = path.join(projectRoot, '.claude');
+    const globalHashes = hashTree(GLOBAL_PRIMITIVES_DIR);
+    const now = new Date().toISOString();
+    const files = {};
+    for (const [relPath, globalHash] of globalHashes) {
+        const localPath = path.join(claudeDir, relPath);
+        if (fs.existsSync(localPath)) {
+            const localHash = hashFile(localPath);
+            files[relPath] = {
+                mode: localHash === globalHash ? 'synced' : 'override',
+                globalHash,
+                localHash,
+                syncedAt: now,
+                ...(localHash !== globalHash ? { overriddenAt: now, reason: 'Existing file at registration time' } : {}),
+            };
+        }
+        else {
+            // Global file not present locally — copy it
+            const localDir = path.dirname(localPath);
+            if (!fs.existsSync(localDir))
+                fs.mkdirSync(localDir, { recursive: true });
+            fs.copyFileSync(path.join(GLOBAL_PRIMITIVES_DIR, relPath), localPath);
+            files[relPath] = {
+                mode: 'synced',
+                globalHash,
+                localHash: globalHash,
+                syncedAt: now,
+            };
+        }
+    }
+    // Workflow
+    let workflow;
+    const workflowPath = path.join(projectRoot, '.claude', 'config', 'workflow.json');
+    if (fs.existsSync(GLOBAL_WORKFLOW_PATH) && fs.existsSync(workflowPath)) {
+        const globalHash = hashFile(GLOBAL_WORKFLOW_PATH);
+        const localHash = hashFile(workflowPath);
+        workflow = {
+            mode: localHash === globalHash ? 'synced' : 'override',
+            globalHash,
+            localHash,
+            syncedAt: now,
+            ...(localHash !== globalHash ? { overriddenAt: now, reason: 'Existing workflow at registration time' } : {}),
+        };
+    }
+    else {
+        workflow = { mode: 'synced', globalHash: '', localHash: '', syncedAt: now };
+    }
+    return { version: 1, files, workflow, newFilesPolicy: 'auto-sync' };
+}
+// ─── Atomic File Copy ───────────────────────────────────────
+/** Copy a file atomically (write to temp, then rename). */
+function atomicCopy(src, dest) {
+    const dir = path.dirname(dest);
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+    const tmp = dest + '.sync-tmp';
+    try {
+        fs.copyFileSync(src, tmp);
+        fs.renameSync(tmp, dest);
+    }
+    catch (err) {
+        try {
+            fs.unlinkSync(tmp);
+        }
+        catch { /* best-effort cleanup */ }
+        throw err;
+    }
+}
+// ─── SyncService ────────────────────────────────────────────
+export class SyncService {
+    constructor() { }
+    // ─── Sync State Computation ──────────────────────────────
+    /** Compute the actual sync state of every tracked file in a project. */
+    computeSyncState(projectId, projectRoot) {
+        let manifest = loadManifest(projectRoot);
+        if (!manifest) {
+            manifest = createInitialManifest(projectRoot);
+            saveManifest(projectRoot, manifest);
+        }
+        const claudeDir = path.join(projectRoot, '.claude');
+        const files = [];
+        for (const [relPath, record] of Object.entries(manifest.files)) {
+            const localPath = path.join(claudeDir, relPath);
+            const globalPath = path.join(GLOBAL_PRIMITIVES_DIR, relPath);
+            const localExists = fs.existsSync(localPath);
+            const globalExists = fs.existsSync(globalPath);
+            let state;
+            let localHash = localExists ? hashFile(localPath) : null;
+            let globalHash = globalExists ? hashFile(globalPath) : null;
+            if (record.mode === 'override') {
+                state = 'override';
+            }
+            else if (!localExists) {
+                state = 'absent';
+            }
+            else if (localHash !== record.localHash) {
+                // Local file changed since last sync — drift
+                state = 'drifted';
+            }
+            else {
+                state = 'synced';
+            }
+            files.push({
+                relativePath: relPath,
+                state,
+                globalHash,
+                localHash,
+                overriddenAt: record.overriddenAt,
+                reason: record.reason,
+            });
+        }
+        // Check for new global files not in manifest
+        if (fs.existsSync(GLOBAL_PRIMITIVES_DIR)) {
+            const globalHashes = hashTree(GLOBAL_PRIMITIVES_DIR);
+            for (const [relPath] of globalHashes) {
+                if (!manifest.files[relPath]) {
+                    files.push({
+                        relativePath: relPath,
+                        state: 'absent',
+                        globalHash: globalHashes.get(relPath) ?? null,
+                        localHash: null,
+                    });
+                }
+            }
+        }
+        // Workflow state
+        const wfLocalPath = path.join(projectRoot, '.claude', 'config', 'workflow.json');
+        let workflowState = 'synced';
+        if (manifest.workflow.mode === 'override') {
+            workflowState = 'override';
+        }
+        else if (fs.existsSync(wfLocalPath)) {
+            const currentLocalHash = hashFile(wfLocalPath);
+            if (currentLocalHash !== manifest.workflow.localHash) {
+                workflowState = 'drifted';
+            }
+        }
+        return {
+            projectId,
+            projectPath: projectRoot,
+            files,
+            workflow: {
+                relativePath: 'workflow.json',
+                state: workflowState,
+                globalHash: manifest.workflow.globalHash || null,
+                localHash: manifest.workflow.localHash || null,
+            },
+        };
+    }
+    /** Compute sync state across ALL registered projects. */
+    computeGlobalSyncState() {
+        const projects = getRegisteredProjects();
+        const allFiles = new Set();
+        const projectStates = [];
+        for (const reg of projects) {
+            if (!reg.enabled || !fs.existsSync(reg.path))
+                continue;
+            const report = this.computeSyncState(reg.id, reg.path);
+            const states = {};
+            for (const f of report.files) {
+                allFiles.add(f.relativePath);
+                states[f.relativePath] = f.state;
+            }
+            projectStates.push({ projectId: reg.id, projectName: reg.name, states });
+        }
+        return { files: [...allFiles].sort(), projects: projectStates };
+    }
+    // ─── Write Operations ────────────────────────────────────
+    /** Propagate a global file change to all synced projects. */
+    propagateGlobalChange(relativePath) {
+        const globalPath = path.join(GLOBAL_PRIMITIVES_DIR, relativePath);
+        if (!fs.existsSync(globalPath)) {
+            return { updated: [], skipped: [], failed: [] };
+        }
+        const globalHash = hashFile(globalPath);
+        const projects = getRegisteredProjects();
+        const result = { updated: [], skipped: [], failed: [] };
+        for (const reg of projects) {
+            if (!reg.enabled || !fs.existsSync(reg.path))
+                continue;
+            const manifest = loadManifest(reg.path);
+            if (!manifest)
+                continue;
+            const record = manifest.files[relativePath];
+            if (!record || record.mode === 'override') {
+                result.skipped.push(reg.id);
+                // Update globalHash even for overrides so drift detection works
+                if (record) {
+                    record.globalHash = globalHash;
+                    saveManifest(reg.path, manifest);
+                }
+                continue;
+            }
+            try {
+                const destPath = path.join(reg.path, '.claude', relativePath);
+                atomicCopy(globalPath, destPath);
+                record.globalHash = globalHash;
+                record.localHash = globalHash;
+                record.syncedAt = new Date().toISOString();
+                saveManifest(reg.path, manifest);
+                result.updated.push(reg.id);
+                log.info('Propagated global change', { file: relativePath, project: reg.id });
+            }
+            catch (err) {
+                result.failed.push({ projectId: reg.id, error: String(err) });
+            }
+        }
+        return result;
+    }
+    /** Create an override for a file in a specific project. */
+    createOverride(projectRoot, relativePath, reason) {
+        const manifest = loadManifest(projectRoot);
+        if (!manifest)
+            return;
+        const record = manifest.files[relativePath];
+        if (!record)
+            return;
+        record.mode = 'override';
+        record.overriddenAt = new Date().toISOString();
+        if (reason)
+            record.reason = reason;
+        // Update localHash to current file content
+        const localPath = path.join(projectRoot, '.claude', relativePath);
+        if (fs.existsSync(localPath)) {
+            record.localHash = hashFile(localPath);
+        }
+        saveManifest(projectRoot, manifest);
+        log.info('Created override', { file: relativePath, reason });
+    }
+    /** Revert an override — replace local file with global version. */
+    revertOverride(projectRoot, relativePath) {
+        const manifest = loadManifest(projectRoot);
+        if (!manifest)
+            return;
+        const record = manifest.files[relativePath];
+        if (!record)
+            return;
+        const globalPath = path.join(GLOBAL_PRIMITIVES_DIR, relativePath);
+        if (!fs.existsSync(globalPath))
+            return;
+        const destPath = path.join(projectRoot, '.claude', relativePath);
+        atomicCopy(globalPath, destPath);
+        const globalHash = hashFile(globalPath);
+        record.mode = 'synced';
+        record.globalHash = globalHash;
+        record.localHash = globalHash;
+        record.syncedAt = new Date().toISOString();
+        delete record.overriddenAt;
+        delete record.reason;
+        saveManifest(projectRoot, manifest);
+        log.info('Reverted override', { file: relativePath });
+    }
+    /** Promote a project override to become the new global version. */
+    promoteOverride(projectRoot, relativePath) {
+        const localPath = path.join(projectRoot, '.claude', relativePath);
+        if (!fs.existsSync(localPath)) {
+            return { updated: [], skipped: [], failed: [{ projectId: 'self', error: 'Local file not found' }] };
+        }
+        // Copy local to global
+        const globalPath = path.join(GLOBAL_PRIMITIVES_DIR, relativePath);
+        atomicCopy(localPath, globalPath);
+        // Update this project's manifest to synced
+        const manifest = loadManifest(projectRoot);
+        if (manifest && manifest.files[relativePath]) {
+            const hash = hashFile(globalPath);
+            manifest.files[relativePath] = {
+                mode: 'synced',
+                globalHash: hash,
+                localHash: hash,
+                syncedAt: new Date().toISOString(),
+            };
+            saveManifest(projectRoot, manifest);
+        }
+        // Propagate to all other synced projects
+        log.info('Promoted override to global', { file: relativePath });
+        return this.propagateGlobalChange(relativePath);
+    }
+    /** Resolve drift — either pin as override or reset to global. */
+    resolveDrift(projectRoot, relativePath, resolution) {
+        if (resolution === 'pin-override') {
+            this.createOverride(projectRoot, relativePath, 'Pinned from drift resolution');
+        }
+        else {
+            this.revertOverride(projectRoot, relativePath);
+        }
+    }
+    // ─── New File Handling ───────────────────────────────────
+    /** Handle a new file appearing in the global primitives directory. */
+    handleNewGlobalFile(relativePath) {
+        const globalPath = path.join(GLOBAL_PRIMITIVES_DIR, relativePath);
+        if (!fs.existsSync(globalPath)) {
+            return { updated: [], skipped: [], failed: [] };
+        }
+        const globalHash = hashFile(globalPath);
+        const projects = getRegisteredProjects();
+        const result = { updated: [], skipped: [], failed: [] };
+        for (const reg of projects) {
+            if (!reg.enabled || !fs.existsSync(reg.path))
+                continue;
+            const manifest = loadManifest(reg.path);
+            if (!manifest)
+                continue;
+            if (manifest.newFilesPolicy === 'prompt') {
+                result.skipped.push(reg.id);
+                continue;
+            }
+            try {
+                const destPath = path.join(reg.path, '.claude', relativePath);
+                atomicCopy(globalPath, destPath);
+                manifest.files[relativePath] = {
+                    mode: 'synced',
+                    globalHash,
+                    localHash: globalHash,
+                    syncedAt: new Date().toISOString(),
+                };
+                saveManifest(reg.path, manifest);
+                result.updated.push(reg.id);
+            }
+            catch (err) {
+                result.failed.push({ projectId: reg.id, error: String(err) });
+            }
+        }
+        return result;
+    }
+    /** Handle a file being deleted from the global primitives directory. */
+    handleGlobalFileDeletion(relativePath) {
+        const projects = getRegisteredProjects();
+        const removed = [];
+        const preserved = [];
+        for (const reg of projects) {
+            if (!reg.enabled || !fs.existsSync(reg.path))
+                continue;
+            const manifest = loadManifest(reg.path);
+            if (!manifest || !manifest.files[relativePath])
+                continue;
+            const record = manifest.files[relativePath];
+            const localPath = path.join(reg.path, '.claude', relativePath);
+            if (record.mode === 'synced') {
+                // Delete the local copy
+                if (fs.existsSync(localPath))
+                    fs.unlinkSync(localPath);
+                delete manifest.files[relativePath];
+                saveManifest(reg.path, manifest);
+                removed.push(reg.id);
+            }
+            else {
+                // Override — preserve the local file, remove from manifest
+                delete manifest.files[relativePath];
+                saveManifest(reg.path, manifest);
+                preserved.push(reg.id);
+            }
+        }
+        return { removed, preserved };
+    }
+    // ─── Impact Preview ──────────────────────────────────────
+    /** Preview which projects would be affected by a global file change. */
+    getImpactPreview(relativePath) {
+        const projects = getRegisteredProjects();
+        const willUpdate = [];
+        const willSkip = [];
+        for (const reg of projects) {
+            if (!reg.enabled || !fs.existsSync(reg.path))
+                continue;
+            const manifest = loadManifest(reg.path);
+            if (!manifest) {
+                willSkip.push({ id: reg.id, reason: 'No sync manifest' });
+                continue;
+            }
+            const record = manifest.files[relativePath];
+            if (!record || record.mode === 'synced') {
+                willUpdate.push(reg.id);
+            }
+            else {
+                willSkip.push({ id: reg.id, reason: record.reason });
+            }
+        }
+        return { willUpdate, willSkip };
+    }
+    // ─── Manifest Management ─────────────────────────────────
+    /** Ensure a project has a sync manifest. Creates one if missing. */
+    ensureManifest(projectRoot) {
+        let manifest = loadManifest(projectRoot);
+        if (!manifest) {
+            manifest = createInitialManifest(projectRoot);
+            saveManifest(projectRoot, manifest);
+        }
+        return manifest;
+    }
+}

package/dist/server/server/services/sync-types.js

@@ -0,0 +1,2 @@
+// ─── Sync State Types ───────────────────────────────────────
+export {};

package/dist/server/server/services/workflow-service.js

@@ -46,11 +46,18 @@ export class WorkflowService {
         else {
             const active = JSON.parse(fs.readFileSync(this.activeConfigPath, 'utf-8'));
             if (!active._defaultDigest) {
-                // Legacy file without digest marker. If content matches current default, stamp it.
-                // If different, it's user-customized — leave it alone.
                 if (configDigest(active) === currentDigest) {
+                    // Exact content match — just stamp it with the digest
                     this.writeWithDigest(this.activeConfigPath, defaultConfig, currentDigest);
                 }
+                else if (this.isLikelyOldDefault(active, defaultConfig)) {
+                    // Same list structure but different edges — old default that needs updating
+                    log.info('Upgrading legacy workflow config to current default');
+                    this.writeWithDigest(this.activeConfigPath, defaultConfig, currentDigest);
+                    this.engine.reload(defaultConfig);
+                    fs.writeFileSync(this.manifestPath, this.engine.generateShellManifest(), 'utf-8');
+                }
+                // else: genuinely user-customized (different list structure), leave alone
             }
             else if (active._defaultDigest !== currentDigest) {
                 // Bundled default changed since last sync — refresh + regenerate manifest
@@ -59,10 +66,14 @@ export class WorkflowService {
                 fs.writeFileSync(this.manifestPath, this.engine.generateShellManifest(), 'utf-8');
             }
         }
-        // Always keep the "default" preset in sync with the bundled default
+        // Always keep the "default" preset in sync with the bundled default.
+        // Copy the raw template bytes to preserve formatting (avoid hash drift from re-serialization).
         const defaultPresetPath = path.join(this.presetsDir, 'default.json');
-        const preset = { _preset: { name: 'default', savedAt: new Date().toISOString(), savedFrom: 'bundled' }, ...defaultConfig };
-        fs.writeFileSync(defaultPresetPath, JSON.stringify(preset, null, 2));
+        const templateBytes = fs.readFileSync(this.defaultConfigPath, 'utf-8');
+        const existing = fs.existsSync(defaultPresetPath) ? fs.readFileSync(defaultPresetPath, 'utf-8') : '';
+        if (existing !== templateBytes) {
+            fs.writeFileSync(defaultPresetPath, templateBytes);
+        }
     }
     setSocketServer(io) {
         this.io = io;
@@ -70,6 +81,16 @@ export class WorkflowService {
     getEngine() {
         return this.engine;
     }
+    /** Check if a legacy config (no digest) is structurally an old default rather than
+     *  a user customization. If it has the same list IDs in the same order, it was
+     *  almost certainly seeded from an older version of the bundled default. */
+    isLikelyOldDefault(active, currentDefault) {
+        if (active.name !== currentDefault.name)
+            return false;
+        const activeListIds = active.lists.map(l => l.id).join(',');
+        const defaultListIds = currentDefault.lists.map(l => l.id).join(',');
+        return activeListIds === defaultListIds;
+    }
     // ─── Validation ──────────────────────────────────────
     validate(config) {
         const errors = [];

package/dist/server/server/services/workflow-service.test.js

@@ -0,0 +1,159 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { WorkflowService } from './workflow-service.js';
+import { WorkflowEngine } from '../../shared/workflow-engine.js';
+import { DEFAULT_CONFIG, MINIMAL_CONFIG } from '../../shared/__fixtures__/workflow-configs.js';
+import { createMockEmitter } from '../__tests__/helpers/mock-emitter.js';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+describe('WorkflowService', () => {
+    let tmpDir;
+    let configDir;
+    let scopesDir;
+    let defaultConfigPath;
+    let engine;
+    let service;
+    beforeEach(() => {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'workflow-svc-test-'));
+        configDir = path.join(tmpDir, 'config');
+        scopesDir = path.join(tmpDir, 'scopes');
+        defaultConfigPath = path.join(tmpDir, 'default-workflow.json');
+        fs.mkdirSync(configDir, { recursive: true });
+        fs.mkdirSync(scopesDir, { recursive: true });
+        // Write the default workflow config that the constructor reads
+        fs.writeFileSync(defaultConfigPath, JSON.stringify(DEFAULT_CONFIG));
+        // Create scope directories for the default workflow
+        for (const list of DEFAULT_CONFIG.lists) {
+            if (list.hasDirectory) {
+                fs.mkdirSync(path.join(scopesDir, list.id), { recursive: true });
+            }
+        }
+        engine = new WorkflowEngine(DEFAULT_CONFIG);
+        service = new WorkflowService(configDir, engine, scopesDir, defaultConfigPath);
+        service.setSocketServer(createMockEmitter());
+    });
+    afterEach(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    // ─── validate() ──────────────────────────────────────────
+    describe('validate()', () => {
+        it('passes for valid config', () => {
+            const result = service.validate(DEFAULT_CONFIG);
+            expect(result.valid).toBe(true);
+            expect(result.errors).toHaveLength(0);
+        });
+        it('fails for invalid config shape', () => {
+            const result = service.validate({ version: 2 });
+            expect(result.valid).toBe(false);
+            expect(result.errors.length).toBeGreaterThan(0);
+        });
+        it('fails for duplicate list IDs', () => {
+            const config = {
+                ...MINIMAL_CONFIG,
+                lists: [
+                    ...MINIMAL_CONFIG.lists,
+                    { ...MINIMAL_CONFIG.lists[0] }, // duplicate 'todo'
+                ],
+            };
+            const result = service.validate(config);
+            expect(result.valid).toBe(false);
+            expect(result.errors.some(e => e.toLowerCase().includes('duplicate'))).toBe(true);
+        });
+        it('fails for edges referencing non-existent lists', () => {
+            const config = {
+                ...MINIMAL_CONFIG,
+                edges: [
+                    { from: 'todo', to: 'nonexistent', direction: 'forward', command: null, confirmLevel: 'quick', label: 'X', description: 'X' },
+                ],
+            };
+            const result = service.validate(config);
+            expect(result.valid).toBe(false);
+        });
+        it('fails for zero entry points', () => {
+            const config = {
+                ...MINIMAL_CONFIG,
+                lists: MINIMAL_CONFIG.lists.map(l => ({ ...l, isEntryPoint: false })),
+            };
+            const result = service.validate(config);
+            expect(result.valid).toBe(false);
+        });
+    });
+    // ─── getActive() / updateActive() ────────────────────────
+    describe('getActive()', () => {
+        it('returns active workflow config', () => {
+            const config = service.getActive();
+            expect(config.name).toBe(DEFAULT_CONFIG.name);
+            expect(config.version).toBe(1);
+        });
+        it('strips _defaultDigest from returned config', () => {
+            const config = service.getActive();
+            expect(config._defaultDigest).toBeUndefined();
+        });
+    });
+    describe('updateActive()', () => {
+        it('updates config and returns valid result', () => {
+            const result = service.updateActive(DEFAULT_CONFIG);
+            expect(result.valid).toBe(true);
+        });
+        it('rejects invalid config', () => {
+            const result = service.updateActive({ version: 1, name: 'Bad', lists: [], edges: [] });
+            expect(result.valid).toBe(false);
+        });
+    });
+    // ─── Presets ──────────────────────────────────────────────
+    describe('presets', () => {
+        it('savePreset() creates a preset file', () => {
+            service.savePreset('test-preset');
+            const presets = service.listPresets();
+            expect(presets.some(p => p.name === 'test-preset')).toBe(true);
+        });
+        it('listPresets() returns all saved presets', () => {
+            service.savePreset('preset-a');
+            service.savePreset('preset-b');
+            const presets = service.listPresets();
+            expect(presets.length).toBeGreaterThanOrEqual(2);
+        });
+        it('getPreset() loads preset by name', () => {
+            service.savePreset('loadable');
+            const config = service.getPreset('loadable');
+            expect(config.version).toBe(1);
+        });
+        it('getPreset() throws for non-existent preset', () => {
+            expect(() => service.getPreset('nonexistent')).toThrow();
+        });
+        it('deletePreset() removes preset file', () => {
+            service.savePreset('to-delete');
+            service.deletePreset('to-delete');
+            expect(() => service.getPreset('to-delete')).toThrow();
+        });
+        it('deletePreset() blocks deletion of "default"', () => {
+            expect(() => service.deletePreset('default')).toThrow();
+        });
+    });
+    // ─── previewMigration() ──────────────────────────────────
+    describe('previewMigration()', () => {
+        it('detects removed lists', () => {
+            // Preview migrating from DEFAULT_CONFIG (7 lists) to MINIMAL_CONFIG (2 lists)
+            const plan = service.previewMigration(MINIMAL_CONFIG);
+            expect(plan.removedLists.length).toBeGreaterThan(0);
+        });
+        it('returns no-op plan when configs have same lists', () => {
+            const plan = service.previewMigration(DEFAULT_CONFIG);
+            expect(plan.valid).toBe(true);
+            expect(plan.removedLists).toHaveLength(0);
+            expect(plan.orphanedScopes).toHaveLength(0);
+        });
+        it('returns valid: false for invalid config', () => {
+            const plan = service.previewMigration({ version: 1, name: 'Bad', lists: [], edges: [] });
+            expect(plan.valid).toBe(false);
+        });
+    });
+    // ─── getEngine() ─────────────────────────────────────────
+    describe('getEngine()', () => {
+        it('returns the active workflow engine', () => {
+            const e = service.getEngine();
+            expect(e).toBeDefined();
+            expect(e.getLists().length).toBeGreaterThan(0);
+        });
+    });
+});