@traits-dev/core 0.3.0 → 0.4.0

package/dist/internal.js

@@ -48,6 +48,37 @@ function isClaudeModel(model) {
 function isGptModel(model) {
   return /gpt/i.test(String(model ?? ""));
 }
+function isLockedRule(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const candidate = value;
+  if (typeof candidate.rule !== "string" || candidate.rule.trim().length === 0) return false;
+  if (candidate.locked != null && typeof candidate.locked !== "boolean") return false;
+  return true;
+}
+function ruleConstraintText(entry) {
+  if (typeof entry === "string") {
+    const text = entry.trim();
+    return text.length > 0 ? text : null;
+  }
+  if (isLockedRule(entry)) {
+    return entry.rule.trim();
+  }
+  return null;
+}
+function normalizeRuleConstraints(value) {
+  const out = [];
+  for (const entry of asArray(value)) {
+    if (typeof entry === "string") {
+      const text = entry.trim();
+      if (!text) continue;
+      out.push({ rule: text, locked: false });
+      continue;
+    }
+    if (!isLockedRule(entry)) continue;
+    out.push({ rule: entry.rule.trim(), locked: Boolean(entry.locked) });
+  }
+  return out;
+}
 
 // src/profile/merge.ts
 var PASS_THROUGH_FIELDS = /* @__PURE__ */ new Set([
@@ -63,17 +94,6 @@ var PASS_THROUGH_FIELDS = /* @__PURE__ */ new Set([
   "behavioral_rules_remove",
   "context_adaptations_remove"
 ]);
-function dedupExact(items) {
-  const seen = /* @__PURE__ */ new Set();
-  const out = [];
-  for (const item of items) {
-    const key = String(item);
-    if (seen.has(key)) continue;
-    seen.add(key);
-    out.push(item);
-  }
-  return out;
-}
 function dedupCaseInsensitive(items) {
   const seen = /* @__PURE__ */ new Set();
   const out = [];
@@ -116,8 +136,29 @@ function mergeVocabulary(parentVocab = {}, childVocab = {}) {
   if (mergedForbidden.length) merged.forbidden_terms = mergedForbidden;
   return merged;
 }
+function mergeRuleConstraints(parentRules = [], childRules = [], options) {
+  const out = [];
+  const byKey = /* @__PURE__ */ new Map();
+  const combined = [
+    ...normalizeRuleConstraints(parentRules),
+    ...normalizeRuleConstraints(childRules)
+  ];
+  for (const entry of combined) {
+    const key = options.caseInsensitive ? entry.rule.toLowerCase() : entry.rule;
+    const existingIndex = byKey.get(key);
+    if (existingIndex == null) {
+      byKey.set(key, out.length);
+      out.push({ rule: entry.rule, locked: entry.locked });
+      continue;
+    }
+    out[existingIndex].locked = out[existingIndex].locked || entry.locked;
+  }
+  return out.map(
+    (entry) => entry.locked ? { rule: entry.rule, locked: true } : entry.rule
+  );
+}
 function mergeBehavioralRules(parentRules = [], childRules = []) {
-  return dedupExact([...asArray(parentRules), ...asArray(childRules)]);
+  return mergeRuleConstraints(parentRules, childRules, { caseInsensitive: false });
 }
 function mergeContextAdaptations(parentAdaptations = [], childAdaptations = []) {
   const base = asArray(parentAdaptations).map((item) => clone(item));
@@ -149,13 +190,13 @@ function mergeCapabilities(parentCapabilities, childCapabilities) {
     ...asArray(parentCapabilities.tools),
     ...asArray(childCapabilities.tools)
   ]);
-  const mergedConstraints = dedupCaseInsensitive([
-    ...asArray(parentCapabilities.constraints),
-    ...asArray(childCapabilities.constraints)
-  ]);
   return {
     tools: mergedTools,
-    constraints: mergedConstraints,
+    constraints: mergeRuleConstraints(
+      parentCapabilities.constraints,
+      childCapabilities.constraints,
+      { caseInsensitive: true }
+    ),
     handoff: {
       trigger: childCapabilities.handoff?.trigger ?? parentCapabilities.handoff?.trigger ?? "",
       action: childCapabilities.handoff?.action ?? parentCapabilities.handoff?.action ?? ""
@@ -178,9 +219,15 @@ function applyExplicitRemovals(childProfile, mergedProfile) {
   );
   const childAdaptationRemovals = asArray(childProfile.context_adaptations_remove);
   if (childBehavioralRemovals.length) {
-    mergedProfile.behavioral_rules = asArray(mergedProfile.behavioral_rules).filter(
-      (rule) => !childBehavioralRemovals.includes(rule)
-    );
+    mergedProfile.behavioral_rules = asArray(
+      mergedProfile.behavioral_rules
+    ).filter((ruleEntry) => {
+      const ruleText = ruleConstraintText(ruleEntry);
+      if (!ruleText) return false;
+      if (!childBehavioralRemovals.includes(ruleText)) return true;
+      if (typeof ruleEntry === "object" && ruleEntry.locked === true) return true;
+      return false;
+    });
   }
   if (childForbiddenRemovals.length) {
     const nextForbidden = removeCaseInsensitive(
@@ -235,37 +282,89 @@ function mergeProfiles(parentProfile, childProfile) {
 }
 
 // src/profile/extends.ts
+function normalizeExtendsTargets(value) {
+  if (value == null) return [];
+  if (typeof value === "string") {
+    return value.trim().length > 0 ? [value] : null;
+  }
+  if (!Array.isArray(value) || value.length === 0) return null;
+  const targets = [];
+  for (const item of value) {
+    if (typeof item !== "string" || item.trim().length === 0) {
+      return null;
+    }
+    targets.push(item);
+  }
+  return targets;
+}
 function resolveExtends(profilePath, options = {}) {
   const diagnostics = { warnings: [], errors: [] };
   const childProfile = loadProfileFile(profilePath);
-  if (!childProfile?.extends) {
+  const extendsTargets = normalizeExtendsTargets(childProfile?.extends);
+  if (!extendsTargets || extendsTargets.length === 0) {
     return {
       profile: childProfile,
       parentPath: null,
+      parentPaths: [],
+      parentProfile: null,
       diagnostics
     };
   }
-  const parentPath = resolveParentPath(profilePath, childProfile.extends, options);
-  if (!parentPath) {
-    diagnostics.errors.push({
-      code: "E_RESOLVE_EXTENDS",
-      severity: "error",
-      message: `Unable to resolve parent profile "${childProfile.extends}".`
-    });
-    return { profile: childProfile, parentPath: null, diagnostics };
-  }
-  const parentProfile = loadProfileFile(parentPath);
-  if (parentProfile?.extends) {
-    diagnostics.errors.push({
-      code: "E_EXTENDS_CHAIN",
-      severity: "error",
-      message: "extends chains are not supported in MVP."
-    });
-    return { profile: childProfile, parentPath, diagnostics };
+  const parentPaths = [];
+  let mergedParent = null;
+  for (const extendsName of extendsTargets) {
+    const parentPath = resolveParentPath(profilePath, extendsName, options);
+    if (!parentPath) {
+      diagnostics.errors.push({
+        code: "E_RESOLVE_EXTENDS",
+        severity: "error",
+        message: `Unable to resolve parent profile "${extendsName}".`
+      });
+      return {
+        profile: childProfile,
+        parentPath: parentPaths[0] ?? null,
+        parentPaths,
+        parentProfile: null,
+        diagnostics
+      };
+    }
+    const parentProfile2 = loadProfileFile(parentPath);
+    if (parentProfile2?.extends) {
+      diagnostics.errors.push({
+        code: "E_EXTENDS_CHAIN",
+        severity: "error",
+        message: "extends chains are not supported in MVP."
+      });
+      return {
+        profile: childProfile,
+        parentPath: parentPaths[0] ?? parentPath,
+        parentPaths: [...parentPaths, parentPath],
+        parentProfile: null,
+        diagnostics
+      };
+    }
+    parentPaths.push(parentPath);
+    mergedParent = mergedParent ? mergeProfiles(mergedParent, parentProfile2) : parentProfile2;
+  }
+  const parentProfile = mergedParent;
+  if (!parentProfile) {
+    return {
+      profile: childProfile,
+      parentPath: null,
+      parentPaths: [],
+      parentProfile: null,
+      diagnostics
+    };
   }
   const merged = mergeProfiles(parentProfile, childProfile);
   delete merged.extends;
-  return { profile: merged, parentPath, diagnostics };
+  return {
+    profile: merged,
+    parentPath: parentPaths[0] ?? null,
+    parentPaths,
+    parentProfile,
+    diagnostics
+  };
 }
 
 // src/profile/normalize.ts
@@ -310,7 +409,7 @@ function resolveActiveContext(profile, context = {}) {
 
 // src/validator/overspec.ts
 function computeConstraintCount(profile) {
-  const behavioralRules = asArray(profile?.behavioral_rules).length;
+  const behavioralRules = normalizeRuleConstraints(profile?.behavioral_rules).length;
   const preferredTerms = asArray(profile?.vocabulary?.preferred_terms).length;
   const forbiddenTerms = asArray(profile?.vocabulary?.forbidden_terms).length;
   const contextAdaptations = asArray(profile?.context_adaptations).length;
@@ -352,7 +451,7 @@ function checkOverspec(profile) {
 
 // src/validator/schema.ts
 var HUMOR_STYLES = ["none", "dry", "subtle-wit", "playful"];
-var SUPPORTED_SCHEMAS = /* @__PURE__ */ new Set(["v1.4", "v1.5"]);
+var SUPPORTED_SCHEMAS = /* @__PURE__ */ new Set(["v1.4", "v1.5", "v1.6"]);
 var TOP_LEVEL_KEYS = /* @__PURE__ */ new Set([
   "schema",
   "meta",
@@ -384,6 +483,9 @@ function isString(value) {
 function isStringArray(value) {
   return Array.isArray(value) && value.every((item) => typeof item === "string");
 }
+function isNonEmptyStringArray(value) {
+  return Array.isArray(value) && value.length > 0 && value.every((item) => typeof item === "string" && item.trim().length > 0);
+}
 function pushDiagnostic(target, code, message, location) {
   target.push({
     code,
@@ -409,6 +511,66 @@ function validateScalarField(parent, key, location, diagnostics) {
     );
   }
 }
+function validateRuleConstraintArray(value, field, diagnostics, options) {
+  if (!Array.isArray(value)) {
+    pushDiagnostic(
+      diagnostics,
+      "V001",
+      `Expected "${field}" to be an array`,
+      field
+    );
+    return;
+  }
+  value.forEach((entry, idx) => {
+    const location = `${field}[${idx}]`;
+    if (typeof entry === "string") return;
+    if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+      pushDiagnostic(
+        diagnostics,
+        "V001",
+        `Expected "${location}" to be a string or { rule, locked? } object`,
+        location
+      );
+      return;
+    }
+    if (!options.allowObjects) {
+      pushDiagnostic(
+        diagnostics,
+        "V001",
+        `Object rule entries in "${field}" require schema version "v1.6"`,
+        location
+      );
+      return;
+    }
+    const ruleObject = entry;
+    for (const key of Object.keys(ruleObject)) {
+      if (key !== "rule" && key !== "locked") {
+        pushDiagnostic(
+          diagnostics,
+          "V001",
+          `Unknown key "${key}" in ${location}`,
+          `${location}.${key}`
+        );
+      }
+    }
+    if (!isString(ruleObject.rule)) {
+      pushDiagnostic(
+        diagnostics,
+        "V001",
+        `Expected "${location}.rule" to be a non-empty string`,
+        `${location}.rule`
+      );
+    }
+    if (ruleObject.locked != null && typeof ruleObject.locked !== "boolean") {
+      pushDiagnostic(
+        diagnostics,
+        "V001",
+        `Expected "${location}.locked" to be a boolean`,
+        `${location}.locked`
+      );
+    }
+  });
+}
 function validateDimensionValue(value, dimension, location, dimensionsDiagnostics, rangeDiagnostics) {
   if (typeof value === "string") {
     if (!LEVEL_INDEX.has(value)) {
@@ -559,13 +721,25 @@ function validateSchema(profile) {
       "schema"
     );
   }
-  if (profile.extends != null && !isString(profile.extends)) {
-    pushDiagnostic(
-      structureDiagnostics,
-      "V001",
-      `Expected "extends" to be a non-empty string`,
-      "extends"
-    );
+  if (profile.extends != null) {
+    const isStringExtends = isString(profile.extends);
+    const isArrayExtends = isNonEmptyStringArray(profile.extends);
+    if (!isStringExtends && !isArrayExtends) {
+      pushDiagnostic(
+        structureDiagnostics,
+        "V001",
+        `Expected "extends" to be a non-empty string or non-empty array of non-empty strings`,
+        "extends"
+      );
+    }
+    if (Array.isArray(profile.extends) && profile.schema !== "v1.6") {
+      pushDiagnostic(
+        structureDiagnostics,
+        "V001",
+        `Array "extends" requires schema version "v1.6"`,
+        "extends"
+      );
+    }
   }
   if (!isObject(profile.meta)) {
     pushDiagnostic(structureDiagnostics, "V001", `Missing required "meta" section`, "meta");
@@ -691,20 +865,17 @@ function validateSchema(profile) {
       }
     }
   }
-  if (profile.behavioral_rules != null && !isStringArray(profile.behavioral_rules)) {
-    pushDiagnostic(
-      structureDiagnostics,
-      "V001",
-      `Expected "behavioral_rules" to be an array of strings`,
-      "behavioral_rules"
-    );
+  if (profile.behavioral_rules != null) {
+    validateRuleConstraintArray(profile.behavioral_rules, "behavioral_rules", structureDiagnostics, {
+      allowObjects: profile.schema === "v1.6"
+    });
   }
   if (profile.capabilities != null) {
-    if (profile.schema !== "v1.5") {
+    if (profile.schema !== "v1.5" && profile.schema !== "v1.6") {
       pushDiagnostic(
         structureDiagnostics,
         "V001",
-        `The "capabilities" section requires schema version "v1.5"`,
+        `The "capabilities" section requires schema version "v1.5" or "v1.6"`,
         "capabilities"
       );
     }
@@ -734,13 +905,20 @@ function validateSchema(profile) {
           "capabilities.tools"
         );
       }
-      if (!isStringArray(profile.capabilities.constraints)) {
+      if (profile.capabilities.constraints == null) {
         pushDiagnostic(
           structureDiagnostics,
           "V001",
-          `Expected "capabilities.constraints" to be an array of strings`,
+          `Expected "capabilities.constraints" to be an array`,
           "capabilities.constraints"
         );
+      } else {
+        validateRuleConstraintArray(
+          profile.capabilities.constraints,
+          "capabilities.constraints",
+          structureDiagnostics,
+          { allowObjects: profile.schema === "v1.6" }
+        );
       }
       if (!isObject(profile.capabilities.handoff)) {
         pushDiagnostic(
@@ -1037,7 +1215,9 @@ function collectS001Candidates(profile) {
       text: normalizeText(profile.identity.backstory)
     });
   }
-  asArray(profile?.behavioral_rules).forEach((rule, idx) => {
+  asArray(profile?.behavioral_rules).forEach((ruleEntry, idx) => {
+    const rule = ruleConstraintText(ruleEntry);
+    if (!rule) return;
     candidates.push({
       location: `behavioral_rules[${idx}]`,
       text: normalizeText(rule)
@@ -1057,7 +1237,9 @@ function collectS001Candidates(profile) {
 }
 function collectS005Candidates(profile) {
   const candidates = [];
-  asArray(profile?.behavioral_rules).forEach((rule, idx) => {
+  asArray(profile?.behavioral_rules).forEach((ruleEntry, idx) => {
+    const rule = ruleConstraintText(ruleEntry);
+    if (!rule) return;
     candidates.push({
       location: `behavioral_rules[${idx}]`,
       text: normalizeText(rule)
@@ -1089,7 +1271,9 @@ function collectS005Candidates(profile) {
 }
 function collectS008Candidates(profile) {
   const candidates = [];
-  asArray(profile?.behavioral_rules).forEach((rule, idx) => {
+  asArray(profile?.behavioral_rules).forEach((ruleEntry, idx) => {
+    const rule = ruleConstraintText(ruleEntry);
+    if (!rule) return;
     candidates.push({
       location: `behavioral_rules[${idx}]`,
       text: normalizeText(rule)
@@ -1233,6 +1417,19 @@ function checkS006(parentProfile, childProfile, mergedProfile) {
       severity: "warning",
       message: "Explicit behavioral_rules_remove detected. Behavioral rules are safety-relevant."
     });
+    const lockedParentRules = new Set(
+      normalizeRuleConstraints(parentProfile.behavioral_rules).filter((rule) => rule.locked).map((rule) => rule.rule)
+    );
+    const lockedRemovals = childBehavioralRemovals.filter(
+      (rule) => lockedParentRules.has(rule)
+    );
+    if (lockedRemovals.length > 0) {
+      diagnostics.push({
+        code: "S006",
+        severity: "error",
+        message: `behavioral_rules_remove attempted to remove locked inherited rules: ${lockedRemovals.join("; ")}`
+      });
+    }
   }
   if (childForbiddenRemovals.length) {
     diagnostics.push({
@@ -1241,9 +1438,9 @@ function checkS006(parentProfile, childProfile, mergedProfile) {
       message: "Explicit vocabulary.forbidden_terms_remove detected. Forbidden terms are safety-relevant."
     });
   }
-  const parentBehavioralCount = asArray(parentProfile.behavioral_rules).length;
+  const parentBehavioralCount = normalizeRuleConstraints(parentProfile.behavioral_rules).length;
   const parentForbiddenCount = asArray(parentProfile?.vocabulary?.forbidden_terms).length;
-  const mergedBehavioralCount = asArray(mergedProfile.behavioral_rules).length;
+  const mergedBehavioralCount = normalizeRuleConstraints(mergedProfile.behavioral_rules).length;
   const mergedForbiddenCount = asArray(mergedProfile?.vocabulary?.forbidden_terms).length;
   if (mergedBehavioralCount < parentBehavioralCount || mergedForbiddenCount < parentForbiddenCount) {
     diagnostics.push({
@@ -1413,11 +1610,10 @@ function validateProfile(profilePath, options = {}) {
     (diagnostic) => normalizeDiagnosticSeverity(diagnostic, "error")
   );
   let s006Diagnostics = [];
-  if (resolvedErrors.length === 0 && resolved.parentPath) {
+  if (resolvedErrors.length === 0 && resolved.parentProfile) {
     try {
       const childProfile = loadProfileFile(profilePath);
-      const parentProfile = loadProfileFile(resolved.parentPath);
-      s006Diagnostics = checkS006(parentProfile, childProfile, resolved.profile);
+      s006Diagnostics = checkS006(resolved.parentProfile, childProfile, resolved.profile);
     } catch (error) {
       s006Diagnostics = [
         {
@@ -1779,7 +1975,7 @@ function renderPersonalityText(profile, model, contextResolution, compileOptions
   lines.push(`Protected refusal terms (always available): ${PROTECTED_REFUSAL_TERMS.join("; ")}`);
   lines.push("");
   lines.push("[BEHAVIORAL RULES]");
-  const rules = asArray(profile.behavioral_rules);
+  const rules = normalizeRuleConstraints(profile.behavioral_rules).map((entry) => entry.rule);
   if (rules.length === 0) {
     lines.push("- (none)");
   } else {
@@ -1787,10 +1983,12 @@ function renderPersonalityText(profile, model, contextResolution, compileOptions
       lines.push(`- ${rule}`);
     }
   }
-  if (profile.schema === "v1.5" && profile.capabilities) {
+  if ((profile.schema === "v1.5" || profile.schema === "v1.6") && profile.capabilities) {
     const capabilities = profile.capabilities;
     const tools = asArray(capabilities.tools);
-    const constraints = asArray(capabilities.constraints);
+    const constraints = normalizeRuleConstraints(capabilities.constraints).map(
+      (entry) => entry.rule
+    );
     lines.push("");
     lines.push("[CAPABILITY BOUNDARIES]");
     lines.push(
@@ -2084,7 +2282,7 @@ function evaluateTier1Response(profile, responseText, options = {}) {
     forbidden_matched: forbiddenMatches,
     pass: forbiddenMatches === 0
   };
-  const behavioralRules = asArray(profile?.behavioral_rules);
+  const behavioralRules = normalizeRuleConstraints(profile?.behavioral_rules);
   const structureCheck = {
     behavioral_rule_count: behavioralRules.length,
     response_non_empty: response.trim().length > 0,
@@ -2766,7 +2964,9 @@ function buildJudgeUserPrompt(profile, sample) {
   const targets = collectVoiceTargets(profile);
   const preferredTerms = asArray(profile?.vocabulary?.preferred_terms);
   const forbiddenTerms = asArray(profile?.vocabulary?.forbidden_terms);
-  const behavioralRules = asArray(profile?.behavioral_rules);
+  const behavioralRules = normalizeRuleConstraints(profile?.behavioral_rules).map(
+    (entry) => entry.rule
+  );
   return [
     `Profile: ${profile?.meta?.name ?? "unknown"}`,
     `Role: ${profile?.identity?.role ?? "assistant"}`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@traits-dev/core",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Core traits.dev SDK for voice profile validation, behavioral policy compilation, and evaluation.",
   "keywords": [
     "traits-dev",