superbee 0.4.3-pre.6 → 0.4.3-pre.7

package/dist/superbee.mjs

@@ -44,7 +44,7 @@ var __toESM = (mod, isNodeMode, target3) => (target3 = mod != null ? __create(__
 var define_SUPERBEE_BUILD_IDENTITY_default;
 var init_define_SUPERBEE_BUILD_IDENTITY = __esm({
   "<define:__SUPERBEE_BUILD_IDENTITY__>"() {
-    define_SUPERBEE_BUILD_IDENTITY_default = { schema: "superbee.build-identity.v1", package: { name: "superbee", version: "0.4.3-pre.6" }, source: { commit: "e4dbff30e3806cbcb70d658e41f3a29d46d069c8", dirty: false }, artifact: { channel: "npm-package" }, compatibility_contracts: { skill: 1, hook: 1, mcp: 1 } };
+    define_SUPERBEE_BUILD_IDENTITY_default = { schema: "superbee.build-identity.v1", package: { name: "superbee", version: "0.4.3-pre.7" }, source: { commit: "9d53ab5b75db0b4c25ab0a214551d4211cc150a8", dirty: false }, artifact: { channel: "npm-package" }, compatibility_contracts: { skill: 1, hook: 1, mcp: 1 } };
   }
 });
 
@@ -88299,17 +88299,16 @@ function monotonicEvolutionBlockers(current, desired, blockers) {
       );
     }
   }
-  const currentDeclared = /* @__PURE__ */ new Set([...current.fields.required, ...current.fields.optional]);
   const desiredDeclared = /* @__PURE__ */ new Set([...desired.fields.required, ...desired.fields.optional]);
   for (const [field, desiredValues] of Object.entries(desired.fields.values)) {
     const currentValues = current.fields.values[field];
     if (!currentValues) {
-      if (desiredDeclared.has(field) && !currentDeclared.has(field)) continue;
+      if (desiredDeclared.has(field)) continue;
       evolutionBlocker(
         blockers,
         "RECIPE_EVOLUTION_NON_MONOTONIC",
         desired.id,
-        `automatic evolution cannot add an enum restriction to '${field}' for '${desired.governs}'; only a field newly declared by the same plan may gain one`,
+        `automatic evolution cannot add an enum restriction to '${field}' for '${desired.governs}'; declare '${field}' in fields.required or fields.optional first`,
         field
       );
       continue;
@@ -88368,6 +88367,20 @@ function monotonicEvolutionBlockers(current, desired, blockers) {
     );
   }
 }
+function addedFieldRestrictions(current, desired) {
+  const types = /* @__PURE__ */ new Map();
+  for (const [field, type] of Object.entries(desired.fields.types ?? {})) {
+    if (!Object.hasOwn(current.fields.types ?? {}, field)) types.set(field, type);
+  }
+  const currentDeclared = /* @__PURE__ */ new Set([...current.fields.required, ...current.fields.optional]);
+  const values = /* @__PURE__ */ new Map();
+  for (const [field, allowed] of Object.entries(desired.fields.values)) {
+    if (!Object.hasOwn(current.fields.values, field) && currentDeclared.has(field)) {
+      values.set(field, allowed.map((value) => String(value)));
+    }
+  }
+  return { types, values };
+}
 function addedLinkTypes(current, desired) {
   const currentLinks = current.links ?? {};
   return Object.keys(desired.links ?? {}).filter((linkType) => !Object.hasOwn(currentLinks, linkType));
@@ -88423,6 +88436,7 @@ async function prepareRecipeEvolution(bundle, sourceRecipe) {
   const proofs = [];
   const desiredKinds = /* @__PURE__ */ new Map();
   const addedLinkTexts = /* @__PURE__ */ new Set();
+  const addedRestrictions = /* @__PURE__ */ new Map();
   const skippedConventions = [];
   const installedConventions = await query2(bundle, { prefix: CONVENTIONS_PREFIX, type: "Convention" }, {
     onSkip: (skipped) => skippedConventions.push(skipped)
@@ -88567,6 +88581,7 @@ async function prepareRecipeEvolution(bundle, sourceRecipe) {
     });
     if (!unchanged2 && existing.doc.frontmatter.type === "Convention" && parsedCurrent.ok && parsedCandidate.ok && parsedCurrent.kind.governs === parsedCandidate.kind.governs) {
       monotonicEvolutionBlockers(parsedCurrent.kind, parsedCandidate.kind, blockers);
+      addedRestrictions.set(parsedCandidate.kind.governs, addedFieldRestrictions(parsedCurrent.kind, parsedCandidate.kind));
       for (const linkType of addedLinkTypes(parsedCurrent.kind, parsedCandidate.kind)) addedLinkTexts.add(linkType);
     }
   }
@@ -88651,6 +88666,8 @@ async function prepareRecipeEvolution(bundle, sourceRecipe) {
       );
     }
     for (const kind2 of changingKinds) {
+      const added = addedRestrictions.get(kind2.governs);
+      const violations = /* @__PURE__ */ new Map();
       for (const doc2 of docs) {
         if (String(doc2.frontmatter.type) !== kind2.governs) continue;
         instancesChecked += 1;
@@ -88659,16 +88676,39 @@ async function prepareRecipeEvolution(bundle, sourceRecipe) {
           id: doc2.id,
           current_version: contentVersion(doc2)
         });
-        for (const warning of projectKindValidationWarnings(okfVersion, kind2, validateAgainstKind(doc2, kind2))) {
-          evolutionBlocker(
-            blockers,
-            "RECIPE_EVOLUTION_INSTANCE_INVALID",
-            doc2.id,
-            warning.message,
-            warning.field
-          );
+        const stored = validateAgainstKind(doc2, kind2);
+        const projected = projectKindValidationWarnings(okfVersion, kind2, stored);
+        for (const [index2, warning] of projected.entries()) {
+          const field = stored[index2].field ?? "";
+          const restriction = warning.code === "KIND_FIELD_TYPE" && added?.types.has(field) ? `fields.types.${field}` : (warning.code === "KIND_FIELD_VALUE" || warning.code === "KIND_FIELD_ARITY") && added?.values.has(field) ? `fields.values.${field}` : void 0;
+          if (restriction === void 0) {
+            evolutionBlocker(
+              blockers,
+              "RECIPE_EVOLUTION_INSTANCE_INVALID",
+              doc2.id,
+              warning.message,
+              warning.field
+            );
+            continue;
+          }
+          const entry = violations.get(restriction) ?? { field, docs: /* @__PURE__ */ new Map() };
+          if (!entry.docs.has(doc2.id)) entry.docs.set(doc2.id, warning.message);
+          violations.set(restriction, entry);
         }
       }
+      for (const [restriction, { field, docs: violating }] of violations) {
+        const ids = [...violating.keys()].sort();
+        const named = ids.slice(0, RESTRICTION_BLOCKER_DOC_CAP).join(", ");
+        const more = ids.length > RESTRICTION_BLOCKER_DOC_CAP ? `, and ${ids.length - RESTRICTION_BLOCKER_DOC_CAP} more` : "";
+        const declared = restriction.startsWith("fields.types.") ? `type '${added.types.get(field)}'` : `allowed values [${added.values.get(field).join(", ")}]`;
+        evolutionBlocker(
+          blockers,
+          "RECIPE_EVOLUTION_RESTRICTION_VIOLATED",
+          kind2.id,
+          `adding ${declared} to '${field}' for '${kind2.governs}' would make ${ids.length} existing document(s) invalid: ${named}${more}; fix them first (e.g. ${ids[0]}: ${violating.get(ids[0])})`,
+          restriction
+        );
+      }
     }
     if (addedLinkTexts.size > 0) {
       const proven = new Set(instanceProofs.map((proof) => proof.id));
@@ -88836,7 +88876,7 @@ async function applyRecipeEvolution(bundle, recipe2, expectedPlanToken, actor) {
     counts: { updated, unchanged: completed.length - updated }
   };
 }
-var RECIPE_EVOLUTION_WRITE_REGISTRY, PRESERVED_ROOT_METADATA, BUNDLE_LOCAL_PLACEMENT;
+var RECIPE_EVOLUTION_WRITE_REGISTRY, PRESERVED_ROOT_METADATA, BUNDLE_LOCAL_PLACEMENT, RESTRICTION_BLOCKER_DOC_CAP;
 var init_recipe_evolution = __esm({
   "../cli/src/recipe-evolution.ts"() {
     "use strict";
@@ -88849,6 +88889,7 @@ var init_recipe_evolution = __esm({
     RECIPE_EVOLUTION_WRITE_REGISTRY = { kinds: /* @__PURE__ */ new Map(), warnings: [] };
     PRESERVED_ROOT_METADATA = /* @__PURE__ */ new Set(["timestamp", "actor", "generated", "verified", "superbee_updated_by"]);
     BUNDLE_LOCAL_PLACEMENT = /* @__PURE__ */ new Set(["order"]);
+    RESTRICTION_BLOCKER_DOC_CAP = 10;
   }
 });
 
@@ -89036,7 +89077,9 @@ it compares definitions, permits additive declarations only, revalidates existin
 returns one exact apply command. Applying requires that plan's token, recomputes the preflight, and
 writes each changed convention with exact-version CAS. Concurrent non-target changes are detected
 by a postcondition check and reported with completed work. It never replaces existing values,
-active View assets, or artifacts omitted from the source.
+active View assets, or artifacts omitted from the source. It may add a field type (fields.types) or
+an enum (fields.values) to a declared field only when every existing instance conforms; otherwise
+the plan names the violating documents. It never changes or removes a type or an enum.
 
 Options:
   --dir <path>          Bundle directory (default: discovered from the cwd)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "superbee",
-  "version": "0.4.3-pre.6",
+  "version": "0.4.3-pre.7",
   "type": "module",
   "description": "Agent-facing Superbee CLI for reading and writing local OKF knowledge bundles: context notes, docs, cross-links, and live bundle Views.",
   "keywords": [