@hamak/smart-data-dico 1.19.0 → 1.20.0

package/backend/dist/server.mjs

@@ -37683,7 +37683,8 @@ function normalizeRelationship(rel) {
 }
 function fillAttributeDefaults(entity) {
   const fix = /* @__PURE__ */ __name((attrs) => {
-    for (const a of attrs ?? []) {
+    if (!Array.isArray(attrs)) return;
+    for (const a of attrs) {
       if (a.required === void 0) a.required = false;
       if (a.description === void 0) a.description = "";
       if (a.properties) fix(a.properties);
@@ -45760,7 +45761,7 @@ var init_dictionaryService = __esm({
         let relationships = [];
         let cases = [];
         try {
-          const model = await loadPackage(packageName);
+          const model = await loadPackage(String(dirPath));
           entities = model.entities;
           relationships = model.relationships;
           cases = model.cases.map((c) => ({
@@ -48645,6 +48646,51 @@ var init_serviceService = __esm({
           };
         }
       }
+      /**
+       * Move an entity from one package to another (#move-entity). The entity keeps
+       * its UUID, so every UUID-based reference (relationships — cross-package is
+       * first-class — cases, diagrams, perspectives) keeps resolving; nothing is
+       * orphaned. We write the entity into the target package, then remove it from
+       * the source via the projection directly — this bypasses deleteEntity's
+       * same-package relationship guard, which is meant for destruction, not a
+       * relocation where the references remain valid.
+       */
+      async moveEntity(sourcePackage, entityName, targetPackage) {
+        logger.info(`Moving entity: ${sourcePackage}.${entityName} -> ${targetPackage}`);
+        if (!targetPackage || targetPackage === sourcePackage) {
+          return { success: false, errors: ["Target package must differ from the source package"] };
+        }
+        try {
+          const entity = await readEntityFile(sourcePackage, entityName);
+          if (!entity) {
+            return { success: false, errors: [`Entity ${sourcePackage}.${entityName} not found`] };
+          }
+          const packages = await listMicroservices();
+          if (!packages.includes(targetPackage)) {
+            return { success: false, errors: [`Target package '${targetPackage}' does not exist`] };
+          }
+          const existingInTarget = await readEntityFile(targetPackage, entityName);
+          if (existingInTarget) {
+            return {
+              success: false,
+              errors: [`Target package '${targetPackage}' already has an entity named '${entityName}'`]
+            };
+          }
+          const projection = getProjection(wsId("dictionaries"));
+          entity.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+          await projection.writeEntity(`packages/${targetPackage}/entities/${entity.name}`, entity);
+          const removed = await projection.deleteEntity(`packages/${sourcePackage}/entities/${entity.name}`);
+          if (!removed) {
+            await projection.deleteEntity(`packages/${targetPackage}/entities/${entity.name}`).catch(() => {
+            });
+            return { success: false, errors: ["Failed to remove the entity from the source package"] };
+          }
+          return { success: true, errors: [] };
+        } catch (error48) {
+          logger.error(`Error moving entity: ${error48}`);
+          return { success: false, errors: [`Error moving entity: ${error48}`] };
+        }
+      }
       // --- Relationship CRUD ---
       async getPackageRelationships(packageName) {
         const packagePath = getPackagePath(packageName);
@@ -49107,424 +49153,6 @@ var init_serviceService = __esm({
   }
 });
 
-// backend/src/models/Rule.ts
-function validateRule(rule) {
-  const errors = [];
-  if (!rule.name || typeof rule.name !== "string") {
-    errors.push("Rule name is required");
-  } else if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(rule.name)) {
-    errors.push("Rule name must be kebab-case (lowercase letters, numbers, hyphens)");
-  }
-  if (!rule.description || typeof rule.description !== "string") {
-    errors.push("Rule description is required");
-  }
-  if (!rule.severity || !["info", "warning", "error"].includes(rule.severity)) {
-    errors.push("Rule severity must be one of: info, warning, error");
-  }
-  if (!rule.enforcement || !["save", "process", "advisory"].includes(rule.enforcement)) {
-    errors.push("Rule enforcement must be one of: save, process, advisory");
-  }
-  if (!rule.scope || !["entity", "package", "case", "global"].includes(rule.scope)) {
-    errors.push("Rule scope must be one of: entity, package, case, global");
-  }
-  if (!Array.isArray(rule.targets) || rule.targets.length === 0) {
-    errors.push("Rule must have at least one target");
-  }
-  if (rule.scope === "entity" && !rule.entityUuid) {
-    errors.push("Entity-scoped rules must specify entityUuid");
-  }
-  if (rule.scope === "package" && !rule.packageName) {
-    errors.push("Package-scoped rules must specify packageName");
-  }
-  if (rule.scope === "case" && !rule.caseUuid) {
-    errors.push("Case-scoped rules must specify caseUuid");
-  }
-  if (rule.enforcement === "process") {
-    const stageField = (rule.metadata || []).find((m) => m.name === "process-stage-field");
-    if (!stageField || !stageField.value) {
-      errors.push("Process-enforcement rules must reference a metadata field via process-stage-field");
-    }
-  }
-  return errors;
-}
-var init_Rule = __esm({
-  "backend/src/models/Rule.ts"() {
-    "use strict";
-    __name(validateRule, "validateRule");
-  }
-});
-
-// backend/src/services/ruleService.ts
-var ruleService_exports = {};
-__export(ruleService_exports, {
-  ruleService: () => ruleService
-});
-var RuleService, ruleService;
-var init_ruleService = __esm({
-  "backend/src/services/ruleService.ts"() {
-    "use strict";
-    init_Rule();
-    init_fileOperations();
-    init_uuid();
-    init_logger();
-    init_ProjectionRegistry();
-    init_types();
-    RuleService = class {
-      static {
-        __name(this, "RuleService");
-      }
-      /** List all rules from all storage scopes, optionally filtered. */
-      async listRules(filters = {}) {
-        const all = [];
-        if (!filters.scope || filters.scope === "entity") {
-          const files = await listAllEntityRuleFiles();
-          for (const { service, entityUuid } of files) {
-            const rules = await readEntityRules(service, entityUuid);
-            all.push(...rules);
-          }
-        }
-        if (!filters.scope || filters.scope === "package") {
-          const packages = filters.packageName ? [filters.packageName] : await listPackagesWithRules();
-          for (const pkg of packages) {
-            const rules = await readPackageRules(pkg);
-            all.push(...rules);
-          }
-        }
-        if (!filters.scope || filters.scope === "global") {
-          const globalRules = await readGlobalRules();
-          all.push(...globalRules);
-        }
-        if (!filters.scope || filters.scope === "case") {
-          if (filters.caseUuid) {
-            const rules = await readCaseRules(filters.caseUuid);
-            all.push(...rules);
-          } else {
-            const cases = await listCases();
-            for (const c of cases) {
-              const rules = c.rules || [];
-              all.push(...rules);
-            }
-          }
-        }
-        for (const rule of all) {
-          if (!rule.enforcement) rule.enforcement = "advisory";
-        }
-        return all.filter((rule) => {
-          if (filters.severity && rule.severity !== filters.severity) return false;
-          if (filters.enforcement && rule.enforcement !== filters.enforcement) return false;
-          if (filters.targetUuid) {
-            const hit = rule.targets.some(
-              (t) => t.uuid === filters.targetUuid || t.entityUuid === filters.targetUuid
-            );
-            if (!hit) return false;
-          }
-          return true;
-        });
-      }
-      /** Get a single rule by uuid (scans all scopes). */
-      async getRule(uuid3) {
-        const all = await this.listRules();
-        return all.find((r) => r.uuid === uuid3) || null;
-      }
-      /** List rules whose targets include this entity (or any of its attributes). */
-      async listRulesForEntity(entityUuid) {
-        const all = await this.listRules();
-        return all.filter(
-          (rule) => rule.targets.some(
-            (t) => t.uuid === entityUuid || t.entityUuid === entityUuid
-          )
-        );
-      }
-      /** Create a rule. Storage location is determined by `scope`. */
-      async createRule(input) {
-        if (!input.enforcement) input.enforcement = "advisory";
-        const errors = validateRule(input);
-        if (errors.length > 0) {
-          return { success: false, errors };
-        }
-        let rule = {
-          uuid: generateUUID(),
-          name: input.name,
-          description: input.description,
-          severity: input.severity,
-          enforcement: input.enforcement,
-          scope: input.scope,
-          targets: input.targets,
-          packageName: input.packageName,
-          entityUuid: input.entityUuid,
-          caseUuid: input.caseUuid,
-          expression: input.expression,
-          tags: input.tags,
-          metadata: input.metadata,
-          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-        };
-        rule = await this.applyAutoScope(rule);
-        const saved = await this.saveRuleToScope(rule);
-        if (!saved) return { success: false, errors: ["Failed to write rule to storage"] };
-        return { success: true, rule };
-      }
-      /** Update an existing rule by uuid. Re-routes to new scope if scope changed. */
-      async updateRule(uuid3, input) {
-        const existing = await this.getRule(uuid3);
-        if (!existing) return { success: false, errors: [`Rule ${uuid3} not found`] };
-        let merged = {
-          ...existing,
-          ...input,
-          uuid: existing.uuid,
-          createdAt: existing.createdAt,
-          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-        };
-        const errors = validateRule(merged);
-        if (errors.length > 0) return { success: false, errors };
-        merged = await this.applyAutoScope(merged, existing.scope, existing.packageName);
-        const scopeMoved = existing.scope !== merged.scope || existing.packageName !== merged.packageName || existing.entityUuid !== merged.entityUuid || existing.caseUuid !== merged.caseUuid;
-        if (scopeMoved) {
-          await this.removeRuleFromScope(existing);
-        }
-        const saved = await this.saveRuleToScope(merged);
-        if (!saved) return { success: false, errors: ["Failed to write updated rule to storage"] };
-        return { success: true, rule: merged };
-      }
-      /** Delete a rule by uuid. */
-      async deleteRule(uuid3) {
-        const existing = await this.getRule(uuid3);
-        if (!existing) return { success: false, errors: [`Rule ${uuid3} not found`] };
-        const removed = await this.removeRuleFromScope(existing);
-        if (!removed) return { success: false, errors: ["Failed to remove rule from storage"] };
-        return { success: true };
-      }
-      // ─── Private helpers: route to the right storage location ────────────────
-      async saveRuleToScope(rule) {
-        const projection = getProjection(wsId("dictionaries"));
-        switch (rule.scope) {
-          case "entity": {
-            if (!rule.entityUuid) return false;
-            const files = await listAllEntityRuleFiles();
-            let service = files.find((f) => f.entityUuid === rule.entityUuid)?.service;
-            if (!service) service = rule.packageName;
-            if (!service) {
-              logger.error(`Cannot determine service for entity ${rule.entityUuid}`);
-              return false;
-            }
-            const entity = await this.findEntityByUuid(service, rule.entityUuid);
-            if (!entity) {
-              logger.error(`Entity ${rule.entityUuid} not found in service ${service}`);
-              return false;
-            }
-            const existing = entity.rules || [];
-            const updatedRules = [...existing.filter((r) => r.uuid !== rule.uuid), rule];
-            entity.rules = updatedRules.length > 0 ? updatedRules : void 0;
-            const logicalPath = `packages/${service}/entities/${entity.name}`;
-            try {
-              await projection.writeEntity(logicalPath, entity);
-              return true;
-            } catch (e) {
-              logger.error(`Failed to write entity-scope rule via projection: ${e.message}`);
-              return false;
-            }
-          }
-          case "package": {
-            if (!rule.packageName) return false;
-            const existing = await readPackageRules(rule.packageName);
-            const updated = [...existing.filter((r) => r.uuid !== rule.uuid), rule];
-            const packageLogicalPath = `packages/${rule.packageName}`;
-            try {
-              await projection.writePackageRules(packageLogicalPath, updated);
-              return true;
-            } catch (e) {
-              logger.error(`Failed to write package-scope rules via projection: ${e.message}`);
-              return false;
-            }
-          }
-          case "case": {
-            if (!rule.caseUuid) return false;
-            const c = await readCaseFile(rule.caseUuid);
-            if (!c) return false;
-            const existing = c.rules || [];
-            c.rules = [...existing.filter((r) => r.uuid !== rule.uuid), rule];
-            c.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-            const targetPackage = await this.resolveCaseHomePackage(c);
-            if (!targetPackage) return false;
-            const caseLogicalPath = `packages/${targetPackage}/cases/${c.name}`;
-            try {
-              await projection.writeCase(caseLogicalPath, c);
-              return true;
-            } catch (e) {
-              logger.error(`Failed to write case-scope rule via projection: ${e.message}`);
-              return false;
-            }
-          }
-          case "global": {
-            const existing = await readGlobalRules();
-            const updated = [...existing.filter((r) => r.uuid !== rule.uuid), rule];
-            try {
-              await projection.writeGlobalRules(updated);
-              return true;
-            } catch (e) {
-              logger.error(`Failed to write global rules via projection: ${e.message}`);
-              return false;
-            }
-          }
-          default:
-            return false;
-        }
-      }
-      async removeRuleFromScope(rule) {
-        const projection = getProjection(wsId("dictionaries"));
-        switch (rule.scope) {
-          case "entity": {
-            if (!rule.entityUuid) return false;
-            const files = await listAllEntityRuleFiles();
-            const service = files.find((f) => f.entityUuid === rule.entityUuid)?.service ?? rule.packageName;
-            if (!service) return false;
-            const entity = await this.findEntityByUuid(service, rule.entityUuid);
-            if (!entity) return false;
-            const existing = entity.rules || [];
-            const updatedRules = existing.filter((r) => r.uuid !== rule.uuid);
-            entity.rules = updatedRules.length > 0 ? updatedRules : void 0;
-            const logicalPath = `packages/${service}/entities/${entity.name}`;
-            try {
-              await projection.writeEntity(logicalPath, entity);
-              return true;
-            } catch (e) {
-              logger.error(`Failed to remove entity-scope rule via projection: ${e.message}`);
-              return false;
-            }
-          }
-          case "package": {
-            if (!rule.packageName) return false;
-            const existing = await readPackageRules(rule.packageName);
-            const updated = existing.filter((r) => r.uuid !== rule.uuid);
-            const packageLogicalPath = `packages/${rule.packageName}`;
-            try {
-              await projection.writePackageRules(packageLogicalPath, updated);
-              return true;
-            } catch (e) {
-              logger.error(`Failed to remove package-scope rule via projection: ${e.message}`);
-              return false;
-            }
-          }
-          case "case": {
-            if (!rule.caseUuid) return false;
-            const c = await readCaseFile(rule.caseUuid);
-            if (!c) return false;
-            const existing = c.rules || [];
-            const updated = existing.filter((r) => r.uuid !== rule.uuid);
-            c.rules = updated.length > 0 ? updated : void 0;
-            c.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-            const targetPackage = await this.resolveCaseHomePackage(c);
-            if (!targetPackage) return false;
-            const caseLogicalPath = `packages/${targetPackage}/cases/${c.name}`;
-            try {
-              await projection.writeCase(caseLogicalPath, c);
-              return true;
-            } catch (e) {
-              logger.error(`Failed to remove case-scope rule via projection: ${e.message}`);
-              return false;
-            }
-          }
-          case "global": {
-            const existing = await readGlobalRules();
-            const updated = existing.filter((r) => r.uuid !== rule.uuid);
-            try {
-              await projection.writeGlobalRules(updated);
-              return true;
-            } catch (e) {
-              logger.error(`Failed to remove global rule via projection: ${e.message}`);
-              return false;
-            }
-          }
-          default:
-            return false;
-        }
-      }
-      /**
-       * Load an entity from a package by uuid. Returns null if not found.
-       * Used by entity-scope rule writes to round-trip the parent entity
-       * through `projection.writeEntity`.
-       */
-      async findEntityByUuid(service, entityUuid) {
-        try {
-          const pkg = await loadPackage(service);
-          return pkg.entities.find((e) => e.uuid === entityUuid) ?? null;
-        } catch (error48) {
-          logger.error(`Error loading package ${service} for entity lookup: ${error48}`);
-          return null;
-        }
-      }
-      /**
-       * Resolve the home package for a case so we can construct a
-       * `packages/<pkg>/cases/<name>` logical path. Mirrors the heuristic in
-       * caseService.ts / fileOperations.ts: existing-owner lookup by uuid first,
-       * then first root entity's package, then first package on disk.
-       */
-      async resolveCaseHomePackage(c) {
-        const { listPackages: listPackages3 } = await Promise.resolve().then(() => (init_fileOperations(), fileOperations_exports));
-        const packages = await listPackages3();
-        for (const pkg of packages) {
-          try {
-            const model = await loadPackage(pkg);
-            if (model.ownership.caseByUuid.has(c.uuid)) return pkg;
-          } catch {
-          }
-        }
-        if (c.rootEntities && c.rootEntities.length > 0) {
-          const rootUuid = c.rootEntities[0];
-          for (const pkg of packages) {
-            try {
-              const model = await loadPackage(pkg);
-              if (model.ownership.entityByUuid.has(rootUuid)) return pkg;
-            } catch {
-            }
-          }
-        }
-        return packages[0] || null;
-      }
-      // ─── Auto-promote / auto-demote (#75) ────────────────────────────────
-      /**
-       * Determine the correct scope for a rule based on its targets.
-       * Called before save. If targets span 2+ packages → global.
-       * If all targets are in one package → that package's scope (keep
-       * the caller's intent for entity vs package).
-       */
-      resolveScope(rule) {
-        const packages = /* @__PURE__ */ new Set();
-        for (const t of rule.targets) {
-          if (t.packageName) packages.add(t.packageName);
-        }
-        if (packages.size >= 2) {
-          return { scope: "global" };
-        }
-        if (packages.size === 1) {
-          const pkg = [...packages][0];
-          if (rule.scope === "global") {
-            return { scope: "package", packageName: pkg };
-          }
-        }
-        return { scope: rule.scope, packageName: rule.packageName };
-      }
-      /**
-       * Wrap around createRule/updateRule to apply auto-promote/demote.
-       * Checks if the resolved scope differs from what the caller requested
-       * and adjusts accordingly — including moving the rule between files.
-       */
-      async applyAutoScope(rule, _oldScope, _oldPkg) {
-        const resolved = this.resolveScope(rule);
-        if (resolved.scope !== rule.scope) {
-          logger.info(`Auto-${resolved.scope === "global" ? "promote" : "demote"} rule ${rule.uuid}: ${rule.scope} \u2192 ${resolved.scope}`);
-        }
-        rule.scope = resolved.scope;
-        if (resolved.packageName !== void 0) {
-          rule.packageName = resolved.packageName;
-        }
-        return rule;
-      }
-    };
-    ruleService = new RuleService();
-  }
-});
-
 // backend/node_modules/zod/v4/core/core.js
 // @__NO_SIDE_EFFECTS__
 function $constructor(name21, initializer3, params) {
@@ -50508,7 +50136,7 @@ var init_errors = __esm({
 });
 
 // backend/node_modules/zod/v4/core/parse.js
-var _parse, parse4, _parseAsync, parseAsync, _safeParse, safeParse, _safeParseAsync, safeParseAsync, _encode, encode, _decode, decode, _encodeAsync, encodeAsync, _decodeAsync, decodeAsync, _safeEncode, safeEncode, _safeDecode, safeDecode, _safeEncodeAsync, safeEncodeAsync, _safeDecodeAsync, safeDecodeAsync;
+var _parse, parse3, _parseAsync, parseAsync, _safeParse, safeParse, _safeParseAsync, safeParseAsync, _encode, encode, _decode, decode, _encodeAsync, encodeAsync, _decodeAsync, decodeAsync, _safeEncode, safeEncode, _safeDecode, safeDecode, _safeEncodeAsync, safeEncodeAsync, _safeDecodeAsync, safeDecodeAsync;
 var init_parse = __esm({
   "backend/node_modules/zod/v4/core/parse.js"() {
     init_core();
@@ -50527,7 +50155,7 @@ var init_parse = __esm({
       }
       return result.value;
     }, "_parse");
-    parse4 = /* @__PURE__ */ _parse($ZodRealError);
+    parse3 = /* @__PURE__ */ _parse($ZodRealError);
     _parseAsync = /* @__PURE__ */ __name((_Err) => async (schema, value, _ctx, params) => {
       const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
       let result = schema._zod.run({ value, issues: [] }, ctx);
@@ -53285,10 +52913,10 @@ var init_schemas = __esm({
           throw new Error("implement() must be called with a function");
         }
         return function(...args) {
-          const parsedArgs = inst._def.input ? parse4(inst._def.input, args) : args;
+          const parsedArgs = inst._def.input ? parse3(inst._def.input, args) : args;
           const result = Reflect.apply(func, this, parsedArgs);
           if (inst._def.output) {
-            return parse4(inst._def.output, result);
+            return parse3(inst._def.output, result);
           }
           return result;
         };
@@ -61906,7 +61534,7 @@ __export(core_exports2, {
   isValidJWT: () => isValidJWT,
   locales: () => locales_exports,
   meta: () => meta,
-  parse: () => parse4,
+  parse: () => parse3,
   parseAsync: () => parseAsync,
   prettifyError: () => prettifyError,
   process: () => process2,
@@ -62085,12 +61713,12 @@ var init_errors2 = __esm({
 });
 
 // backend/node_modules/zod/v4/classic/parse.js
-var parse5, parseAsync2, safeParse2, safeParseAsync2, encode2, decode2, encodeAsync2, decodeAsync2, safeEncode2, safeDecode2, safeEncodeAsync2, safeDecodeAsync2;
+var parse4, parseAsync2, safeParse2, safeParseAsync2, encode2, decode2, encodeAsync2, decodeAsync2, safeEncode2, safeDecode2, safeEncodeAsync2, safeDecodeAsync2;
 var init_parse2 = __esm({
   "backend/node_modules/zod/v4/classic/parse.js"() {
     init_core2();
     init_errors2();
-    parse5 = /* @__PURE__ */ _parse(ZodRealError);
+    parse4 = /* @__PURE__ */ _parse(ZodRealError);
     parseAsync2 = /* @__PURE__ */ _parseAsync(ZodRealError);
     safeParse2 = /* @__PURE__ */ _safeParse(ZodRealError);
     safeParseAsync2 = /* @__PURE__ */ _safeParseAsync(ZodRealError);
@@ -62766,7 +62394,7 @@ var init_schemas2 = __esm({
         reg.add(inst, meta3);
         return inst;
       });
-      inst.parse = (data, params) => parse5(inst, data, params, { callee: inst.parse });
+      inst.parse = (data, params) => parse4(inst, data, params, { callee: inst.parse });
       inst.safeParse = (data, params) => safeParse2(inst, data, params);
       inst.parseAsync = async (data, params) => parseAsync2(inst, data, params, { callee: inst.parseAsync });
       inst.safeParseAsync = async (data, params) => safeParseAsync2(inst, data, params);
@@ -64193,7 +63821,7 @@ __export(external_exports, {
   object: () => object,
   optional: () => optional,
   overwrite: () => _overwrite,
-  parse: () => parse5,
+  parse: () => parse4,
   parseAsync: () => parseAsync2,
   partialRecord: () => partialRecord,
   pipe: () => pipe,
@@ -64308,6 +63936,424 @@ var init_agentToolRegistry = __esm({
   }
 });
 
+// backend/src/models/Rule.ts
+function validateRule(rule) {
+  const errors = [];
+  if (!rule.name || typeof rule.name !== "string") {
+    errors.push("Rule name is required");
+  } else if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(rule.name)) {
+    errors.push("Rule name must be kebab-case (lowercase letters, numbers, hyphens)");
+  }
+  if (!rule.description || typeof rule.description !== "string") {
+    errors.push("Rule description is required");
+  }
+  if (!rule.severity || !["info", "warning", "error"].includes(rule.severity)) {
+    errors.push("Rule severity must be one of: info, warning, error");
+  }
+  if (!rule.enforcement || !["save", "process", "advisory"].includes(rule.enforcement)) {
+    errors.push("Rule enforcement must be one of: save, process, advisory");
+  }
+  if (!rule.scope || !["entity", "package", "case", "global"].includes(rule.scope)) {
+    errors.push("Rule scope must be one of: entity, package, case, global");
+  }
+  if (!Array.isArray(rule.targets) || rule.targets.length === 0) {
+    errors.push("Rule must have at least one target");
+  }
+  if (rule.scope === "entity" && !rule.entityUuid) {
+    errors.push("Entity-scoped rules must specify entityUuid");
+  }
+  if (rule.scope === "package" && !rule.packageName) {
+    errors.push("Package-scoped rules must specify packageName");
+  }
+  if (rule.scope === "case" && !rule.caseUuid) {
+    errors.push("Case-scoped rules must specify caseUuid");
+  }
+  if (rule.enforcement === "process") {
+    const stageField = (rule.metadata || []).find((m) => m.name === "process-stage-field");
+    if (!stageField || !stageField.value) {
+      errors.push("Process-enforcement rules must reference a metadata field via process-stage-field");
+    }
+  }
+  return errors;
+}
+var init_Rule = __esm({
+  "backend/src/models/Rule.ts"() {
+    "use strict";
+    __name(validateRule, "validateRule");
+  }
+});
+
+// backend/src/services/ruleService.ts
+var ruleService_exports = {};
+__export(ruleService_exports, {
+  ruleService: () => ruleService
+});
+var RuleService, ruleService;
+var init_ruleService = __esm({
+  "backend/src/services/ruleService.ts"() {
+    "use strict";
+    init_Rule();
+    init_fileOperations();
+    init_uuid();
+    init_logger();
+    init_ProjectionRegistry();
+    init_types();
+    RuleService = class {
+      static {
+        __name(this, "RuleService");
+      }
+      /** List all rules from all storage scopes, optionally filtered. */
+      async listRules(filters = {}) {
+        const all = [];
+        if (!filters.scope || filters.scope === "entity") {
+          const files = await listAllEntityRuleFiles();
+          for (const { service, entityUuid } of files) {
+            const rules = await readEntityRules(service, entityUuid);
+            all.push(...rules);
+          }
+        }
+        if (!filters.scope || filters.scope === "package") {
+          const packages = filters.packageName ? [filters.packageName] : await listPackagesWithRules();
+          for (const pkg of packages) {
+            const rules = await readPackageRules(pkg);
+            all.push(...rules);
+          }
+        }
+        if (!filters.scope || filters.scope === "global") {
+          const globalRules = await readGlobalRules();
+          all.push(...globalRules);
+        }
+        if (!filters.scope || filters.scope === "case") {
+          if (filters.caseUuid) {
+            const rules = await readCaseRules(filters.caseUuid);
+            all.push(...rules);
+          } else {
+            const cases = await listCases();
+            for (const c of cases) {
+              const rules = c.rules || [];
+              all.push(...rules);
+            }
+          }
+        }
+        for (const rule of all) {
+          if (!rule.enforcement) rule.enforcement = "advisory";
+        }
+        return all.filter((rule) => {
+          if (filters.severity && rule.severity !== filters.severity) return false;
+          if (filters.enforcement && rule.enforcement !== filters.enforcement) return false;
+          if (filters.targetUuid) {
+            const hit = rule.targets.some(
+              (t) => t.uuid === filters.targetUuid || t.entityUuid === filters.targetUuid
+            );
+            if (!hit) return false;
+          }
+          return true;
+        });
+      }
+      /** Get a single rule by uuid (scans all scopes). */
+      async getRule(uuid3) {
+        const all = await this.listRules();
+        return all.find((r) => r.uuid === uuid3) || null;
+      }
+      /** List rules whose targets include this entity (or any of its attributes). */
+      async listRulesForEntity(entityUuid) {
+        const all = await this.listRules();
+        return all.filter(
+          (rule) => rule.targets.some(
+            (t) => t.uuid === entityUuid || t.entityUuid === entityUuid
+          )
+        );
+      }
+      /** Create a rule. Storage location is determined by `scope`. */
+      async createRule(input) {
+        if (!input.enforcement) input.enforcement = "advisory";
+        const errors = validateRule(input);
+        if (errors.length > 0) {
+          return { success: false, errors };
+        }
+        let rule = {
+          uuid: generateUUID(),
+          name: input.name,
+          description: input.description,
+          severity: input.severity,
+          enforcement: input.enforcement,
+          scope: input.scope,
+          targets: input.targets,
+          packageName: input.packageName,
+          entityUuid: input.entityUuid,
+          caseUuid: input.caseUuid,
+          expression: input.expression,
+          tags: input.tags,
+          metadata: input.metadata,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        rule = await this.applyAutoScope(rule);
+        const saved = await this.saveRuleToScope(rule);
+        if (!saved) return { success: false, errors: ["Failed to write rule to storage"] };
+        return { success: true, rule };
+      }
+      /** Update an existing rule by uuid. Re-routes to new scope if scope changed. */
+      async updateRule(uuid3, input) {
+        const existing = await this.getRule(uuid3);
+        if (!existing) return { success: false, errors: [`Rule ${uuid3} not found`] };
+        let merged = {
+          ...existing,
+          ...input,
+          uuid: existing.uuid,
+          createdAt: existing.createdAt,
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        const errors = validateRule(merged);
+        if (errors.length > 0) return { success: false, errors };
+        merged = await this.applyAutoScope(merged, existing.scope, existing.packageName);
+        const scopeMoved = existing.scope !== merged.scope || existing.packageName !== merged.packageName || existing.entityUuid !== merged.entityUuid || existing.caseUuid !== merged.caseUuid;
+        if (scopeMoved) {
+          await this.removeRuleFromScope(existing);
+        }
+        const saved = await this.saveRuleToScope(merged);
+        if (!saved) return { success: false, errors: ["Failed to write updated rule to storage"] };
+        return { success: true, rule: merged };
+      }
+      /** Delete a rule by uuid. */
+      async deleteRule(uuid3) {
+        const existing = await this.getRule(uuid3);
+        if (!existing) return { success: false, errors: [`Rule ${uuid3} not found`] };
+        const removed = await this.removeRuleFromScope(existing);
+        if (!removed) return { success: false, errors: ["Failed to remove rule from storage"] };
+        return { success: true };
+      }
+      // ─── Private helpers: route to the right storage location ────────────────
+      async saveRuleToScope(rule) {
+        const projection = getProjection(wsId("dictionaries"));
+        switch (rule.scope) {
+          case "entity": {
+            if (!rule.entityUuid) return false;
+            const files = await listAllEntityRuleFiles();
+            let service = files.find((f) => f.entityUuid === rule.entityUuid)?.service;
+            if (!service) service = rule.packageName;
+            if (!service) {
+              logger.error(`Cannot determine service for entity ${rule.entityUuid}`);
+              return false;
+            }
+            const entity = await this.findEntityByUuid(service, rule.entityUuid);
+            if (!entity) {
+              logger.error(`Entity ${rule.entityUuid} not found in service ${service}`);
+              return false;
+            }
+            const existing = entity.rules || [];
+            const updatedRules = [...existing.filter((r) => r.uuid !== rule.uuid), rule];
+            entity.rules = updatedRules.length > 0 ? updatedRules : void 0;
+            const logicalPath = `packages/${service}/entities/${entity.name}`;
+            try {
+              await projection.writeEntity(logicalPath, entity);
+              return true;
+            } catch (e) {
+              logger.error(`Failed to write entity-scope rule via projection: ${e.message}`);
+              return false;
+            }
+          }
+          case "package": {
+            if (!rule.packageName) return false;
+            const existing = await readPackageRules(rule.packageName);
+            const updated = [...existing.filter((r) => r.uuid !== rule.uuid), rule];
+            const packageLogicalPath = `packages/${rule.packageName}`;
+            try {
+              await projection.writePackageRules(packageLogicalPath, updated);
+              return true;
+            } catch (e) {
+              logger.error(`Failed to write package-scope rules via projection: ${e.message}`);
+              return false;
+            }
+          }
+          case "case": {
+            if (!rule.caseUuid) return false;
+            const c = await readCaseFile(rule.caseUuid);
+            if (!c) return false;
+            const existing = c.rules || [];
+            c.rules = [...existing.filter((r) => r.uuid !== rule.uuid), rule];
+            c.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+            const targetPackage = await this.resolveCaseHomePackage(c);
+            if (!targetPackage) return false;
+            const caseLogicalPath = `packages/${targetPackage}/cases/${c.name}`;
+            try {
+              await projection.writeCase(caseLogicalPath, c);
+              return true;
+            } catch (e) {
+              logger.error(`Failed to write case-scope rule via projection: ${e.message}`);
+              return false;
+            }
+          }
+          case "global": {
+            const existing = await readGlobalRules();
+            const updated = [...existing.filter((r) => r.uuid !== rule.uuid), rule];
+            try {
+              await projection.writeGlobalRules(updated);
+              return true;
+            } catch (e) {
+              logger.error(`Failed to write global rules via projection: ${e.message}`);
+              return false;
+            }
+          }
+          default:
+            return false;
+        }
+      }
+      async removeRuleFromScope(rule) {
+        const projection = getProjection(wsId("dictionaries"));
+        switch (rule.scope) {
+          case "entity": {
+            if (!rule.entityUuid) return false;
+            const files = await listAllEntityRuleFiles();
+            const service = files.find((f) => f.entityUuid === rule.entityUuid)?.service ?? rule.packageName;
+            if (!service) return false;
+            const entity = await this.findEntityByUuid(service, rule.entityUuid);
+            if (!entity) return false;
+            const existing = entity.rules || [];
+            const updatedRules = existing.filter((r) => r.uuid !== rule.uuid);
+            entity.rules = updatedRules.length > 0 ? updatedRules : void 0;
+            const logicalPath = `packages/${service}/entities/${entity.name}`;
+            try {
+              await projection.writeEntity(logicalPath, entity);
+              return true;
+            } catch (e) {
+              logger.error(`Failed to remove entity-scope rule via projection: ${e.message}`);
+              return false;
+            }
+          }
+          case "package": {
+            if (!rule.packageName) return false;
+            const existing = await readPackageRules(rule.packageName);
+            const updated = existing.filter((r) => r.uuid !== rule.uuid);
+            const packageLogicalPath = `packages/${rule.packageName}`;
+            try {
+              await projection.writePackageRules(packageLogicalPath, updated);
+              return true;
+            } catch (e) {
+              logger.error(`Failed to remove package-scope rule via projection: ${e.message}`);
+              return false;
+            }
+          }
+          case "case": {
+            if (!rule.caseUuid) return false;
+            const c = await readCaseFile(rule.caseUuid);
+            if (!c) return false;
+            const existing = c.rules || [];
+            const updated = existing.filter((r) => r.uuid !== rule.uuid);
+            c.rules = updated.length > 0 ? updated : void 0;
+            c.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+            const targetPackage = await this.resolveCaseHomePackage(c);
+            if (!targetPackage) return false;
+            const caseLogicalPath = `packages/${targetPackage}/cases/${c.name}`;
+            try {
+              await projection.writeCase(caseLogicalPath, c);
+              return true;
+            } catch (e) {
+              logger.error(`Failed to remove case-scope rule via projection: ${e.message}`);
+              return false;
+            }
+          }
+          case "global": {
+            const existing = await readGlobalRules();
+            const updated = existing.filter((r) => r.uuid !== rule.uuid);
+            try {
+              await projection.writeGlobalRules(updated);
+              return true;
+            } catch (e) {
+              logger.error(`Failed to remove global rule via projection: ${e.message}`);
+              return false;
+            }
+          }
+          default:
+            return false;
+        }
+      }
+      /**
+       * Load an entity from a package by uuid. Returns null if not found.
+       * Used by entity-scope rule writes to round-trip the parent entity
+       * through `projection.writeEntity`.
+       */
+      async findEntityByUuid(service, entityUuid) {
+        try {
+          const pkg = await loadPackage(service);
+          return pkg.entities.find((e) => e.uuid === entityUuid) ?? null;
+        } catch (error48) {
+          logger.error(`Error loading package ${service} for entity lookup: ${error48}`);
+          return null;
+        }
+      }
+      /**
+       * Resolve the home package for a case so we can construct a
+       * `packages/<pkg>/cases/<name>` logical path. Mirrors the heuristic in
+       * caseService.ts / fileOperations.ts: existing-owner lookup by uuid first,
+       * then first root entity's package, then first package on disk.
+       */
+      async resolveCaseHomePackage(c) {
+        const { listPackages: listPackages3 } = await Promise.resolve().then(() => (init_fileOperations(), fileOperations_exports));
+        const packages = await listPackages3();
+        for (const pkg of packages) {
+          try {
+            const model = await loadPackage(pkg);
+            if (model.ownership.caseByUuid.has(c.uuid)) return pkg;
+          } catch {
+          }
+        }
+        if (c.rootEntities && c.rootEntities.length > 0) {
+          const rootUuid = c.rootEntities[0];
+          for (const pkg of packages) {
+            try {
+              const model = await loadPackage(pkg);
+              if (model.ownership.entityByUuid.has(rootUuid)) return pkg;
+            } catch {
+            }
+          }
+        }
+        return packages[0] || null;
+      }
+      // ─── Auto-promote / auto-demote (#75) ────────────────────────────────
+      /**
+       * Determine the correct scope for a rule based on its targets.
+       * Called before save. If targets span 2+ packages → global.
+       * If all targets are in one package → that package's scope (keep
+       * the caller's intent for entity vs package).
+       */
+      resolveScope(rule) {
+        const packages = /* @__PURE__ */ new Set();
+        for (const t of rule.targets) {
+          if (t.packageName) packages.add(t.packageName);
+        }
+        if (packages.size >= 2) {
+          return { scope: "global" };
+        }
+        if (packages.size === 1) {
+          const pkg = [...packages][0];
+          if (rule.scope === "global") {
+            return { scope: "package", packageName: pkg };
+          }
+        }
+        return { scope: rule.scope, packageName: rule.packageName };
+      }
+      /**
+       * Wrap around createRule/updateRule to apply auto-promote/demote.
+       * Checks if the resolved scope differs from what the caller requested
+       * and adjusts accordingly — including moving the rule between files.
+       */
+      async applyAutoScope(rule, _oldScope, _oldPkg) {
+        const resolved = this.resolveScope(rule);
+        if (resolved.scope !== rule.scope) {
+          logger.info(`Auto-${resolved.scope === "global" ? "promote" : "demote"} rule ${rule.uuid}: ${rule.scope} \u2192 ${resolved.scope}`);
+        }
+        rule.scope = resolved.scope;
+        if (resolved.packageName !== void 0) {
+          rule.packageName = resolved.packageName;
+        }
+        return rule;
+      }
+    };
+    ruleService = new RuleService();
+  }
+});
+
 // backend/src/services/versionService.ts
 var versionService_exports = {};
 __export(versionService_exports, {
@@ -116930,8 +116976,8 @@ function resolveToolCategory(toolName, trustByName) {
   const clean = toolName.replace(/^functions\./, "").split(":")[0];
   const builtin = TOOL_CATEGORY_MAP[clean];
   if (builtin) return builtin;
-  const registered4 = getAgentTool(clean)?.category;
-  if (registered4) return registered4;
+  const registered5 = getAgentTool(clean)?.category;
+  if (registered5) return registered5;
   if (clean.includes(".")) {
     const trust = trustByName.get(clean);
     return trust === "auto" ? "read" : "modify";
@@ -159537,6 +159583,24 @@ var setEntityHidden = /* @__PURE__ */ __name(async (req, res) => {
     res.status(500).json({ message: "Error setting entity visibility", error: error48 });
   }
 }, "setEntityHidden");
+var moveEntity = /* @__PURE__ */ __name(async (req, res) => {
+  try {
+    const { service, entity } = req.params;
+    const targetPackage = typeof req.body?.targetPackage === "string" ? req.body.targetPackage : "";
+    if (!targetPackage) {
+      return res.status(400).json({ message: "targetPackage is required" });
+    }
+    const result = await serviceService.moveEntity(service, entity, targetPackage);
+    if (!result.success) {
+      const notFound = result.errors.some((e) => e.includes("not found"));
+      return res.status(notFound ? 404 : 400).json({ message: "Failed to move entity", errors: result.errors });
+    }
+    res.json({ message: "Entity moved", data: { service, entity, targetPackage } });
+  } catch (error48) {
+    logger.error(`Error moving entity: ${error48}`);
+    res.status(500).json({ message: "Error moving entity", error: error48 });
+  }
+}, "moveEntity");
 var setEntityStyle = /* @__PURE__ */ __name(async (req, res) => {
   try {
     const { service, entity } = req.params;
@@ -159763,7 +159827,46 @@ var deleteRelationship = /* @__PURE__ */ __name(async (req, res) => {
   }
 }, "deleteRelationship");
 
+// backend/src/services/entityMove/agentTools.ts
+init_zod();
+init_agentToolRegistry();
+init_serviceService();
+var registered = false;
+function registerMoveEntityAgentTool() {
+  if (registered) return;
+  registered = true;
+  registerAgentTool({
+    name: "moveEntity",
+    category: "modify",
+    description: "Move an entity from one package to another. The entity keeps its UUID, so relationships (cross-package is first-class), cases and diagrams that reference it keep resolving \u2014 nothing is orphaned. Fails if the target package doesn't exist or already has an entity with the same name.",
+    jsonSchema: {
+      type: "object",
+      required: ["sourcePackage", "entityName", "targetPackage"],
+      properties: {
+        sourcePackage: { type: "string", description: "Package the entity currently lives in" },
+        entityName: { type: "string", description: "Name of the entity to move" },
+        targetPackage: { type: "string", description: "Package to move the entity into" }
+      }
+    },
+    inputSchema: external_exports.object({
+      sourcePackage: external_exports.string(),
+      entityName: external_exports.string(),
+      targetPackage: external_exports.string()
+    }),
+    execute: /* @__PURE__ */ __name(async (args) => {
+      const r = await serviceService.moveEntity(
+        String(args.sourcePackage),
+        String(args.entityName),
+        String(args.targetPackage)
+      );
+      return r.success ? { success: true, entity: args.entityName, from: args.sourcePackage, to: args.targetPackage } : { success: false, errors: r.errors };
+    }, "execute")
+  });
+}
+__name(registerMoveEntityAgentTool, "registerMoveEntityAgentTool");
+
 // backend/src/routes/data-dictionary/entity.routes.ts
+registerMoveEntityAgentTool();
 var router3 = (0, import_express4.Router)();
 router3.get("/api/entities/:microservice/:entityName/attributes", getEntityAttributes);
 router3.get("/api/entities/:microservice/:entityName/related", getRelatedEntities);
@@ -159777,6 +159880,7 @@ router3.put("/api/services/:service/entities/:entity", authorizeJwt(["admin" /*
 router3.delete("/api/services/:service/entities/:entity", authorizeJwt(["admin" /* ADMIN */]), deleteEntity);
 router3.put("/api/services/:service/entities/:entity/hidden", authorizeJwt(["admin" /* ADMIN */, "editor" /* EDITOR */]), setEntityHidden);
 router3.put("/api/services/:service/entities/:entity/style", authorizeJwt(["admin" /* ADMIN */, "editor" /* EDITOR */]), setEntityStyle);
+router3.put("/api/services/:service/entities/:entity/move", authorizeJwt(["admin" /* ADMIN */, "editor" /* EDITOR */]), moveEntity);
 router3.post("/api/services/:service/entities/:entity/submit", authorizeJwt(["admin" /* ADMIN */, "editor" /* EDITOR */]), submitEntity);
 router3.post("/api/services/:service/entities/:entity/approve", authorizeJwt(["admin" /* ADMIN */]), approveEntity);
 router3.post("/api/services/:service/entities/:entity/return", authorizeJwt(["admin" /* ADMIN */]), returnEntity);
@@ -160321,10 +160425,10 @@ init_zod();
 init_agentToolRegistry();
 init_dicoConfigService();
 init_serviceService();
-var registered = false;
+var registered2 = false;
 function registerElementStyleAgentTools() {
-  if (registered) return;
-  registered = true;
+  if (registered2) return;
+  registered2 = true;
   registerAgentTool({
     name: "defineElementStyle",
     category: "modify",
@@ -165089,10 +165193,10 @@ init_zod();
 init_agentToolRegistry();
 init_searchIndexService();
 var KINDS = ["entity", "attribute", "package", "relationship", "rule", "metadata", "case"];
-var registered2 = false;
+var registered3 = false;
 function registerSearchAgentTools() {
-  if (registered2) return;
-  registered2 = true;
+  if (registered3) return;
+  registered3 = true;
   registerAgentTool({
     name: "searchModel",
     category: "read",
@@ -173535,10 +173639,10 @@ function getSynthesisBrief(dataDir, entityName) {
 __name(getSynthesisBrief, "getSynthesisBrief");
 
 // backend/src/services/reverseEngineer/agentTools.ts
-var registered3 = false;
+var registered4 = false;
 function registerReverseEngineerAgentTools() {
-  if (registered3) return;
-  registered3 = true;
+  if (registered4) return;
+  registered4 = true;
   registerAgentTool({
     name: "listSynthesisBriefs",
     category: "read",