@traits-dev/core 0.1.0

package/dist/index.cjs

@@ -0,0 +1,2968 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  compileProfile: () => compileProfile,
+  compileResolvedProfile: () => compileResolvedProfile,
+  evaluateTier1Response: () => evaluateTier1Response,
+  injectPersonality: () => injectPersonality,
+  loadProfileFile: () => loadProfileFile,
+  normalizeProfile: () => normalizeProfile,
+  resolveActiveContext: () => resolveActiveContext,
+  resolveExtends: () => resolveExtends,
+  runImportAnalysis: () => runImportAnalysis,
+  runTier1Evaluation: () => runTier1Evaluation,
+  runTier1EvaluationForProfile: () => runTier1EvaluationForProfile,
+  runTier2Evaluation: () => runTier2Evaluation,
+  runTier2EvaluationForProfile: () => runTier2EvaluationForProfile,
+  runTier3Evaluation: () => runTier3Evaluation,
+  runTier3EvaluationForProfile: () => runTier3EvaluationForProfile,
+  validateEvalScenario: () => validateEvalScenario,
+  validateEvalScenarios: () => validateEvalScenarios,
+  validateProfile: () => validateProfile,
+  validateResolvedProfile: () => validateResolvedProfile
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/profile/load.ts
+var import_node_fs = __toESM(require("fs"), 1);
+var import_node_path = __toESM(require("path"), 1);
+var import_yaml = require("yaml");
+function loadProfileFile(filePath) {
+  const raw = import_node_fs.default.readFileSync(filePath, "utf8");
+  return (0, import_yaml.parse)(raw);
+}
+function resolveParentPath(profilePath, extendsName, options = {}) {
+  const localCandidate = import_node_path.default.join(import_node_path.default.dirname(profilePath), `${extendsName}.yaml`);
+  if (import_node_fs.default.existsSync(localCandidate)) return localCandidate;
+  const bundledDir = options.bundledProfilesDir ?? import_node_path.default.resolve(import_node_path.default.dirname(profilePath), "..");
+  const bundledCandidate = import_node_path.default.join(bundledDir, `${extendsName}.yaml`);
+  if (import_node_fs.default.existsSync(bundledCandidate)) return bundledCandidate;
+  return null;
+}
+
+// src/utils.ts
+var LEVELS = ["very-low", "low", "medium", "high", "very-high"];
+var LEVEL_ORDER = LEVELS;
+var LEVEL_INDEX = new Map(
+  LEVEL_ORDER.map((level, idx) => [level, idx])
+);
+var DIMENSIONS = [
+  "formality",
+  "warmth",
+  "verbosity",
+  "directness",
+  "empathy",
+  "humor"
+];
+var PROTECTED_REFUSAL_TERMS = [
+  "I can't help with that",
+  "I'm not able to",
+  "That's not something I can do",
+  "I need to decline"
+];
+function asArray(value) {
+  if (!Array.isArray(value)) return [];
+  return value;
+}
+function clone(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+function isClaudeModel(model) {
+  return /claude/i.test(String(model ?? ""));
+}
+function isGptModel(model) {
+  return /gpt/i.test(String(model ?? ""));
+}
+
+// src/profile/merge.ts
+var PASS_THROUGH_FIELDS = /* @__PURE__ */ new Set([
+  "schema",
+  "meta",
+  "identity",
+  "voice",
+  "vocabulary",
+  "behavioral_rules",
+  "context_adaptations",
+  "extends",
+  "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 = [];
+  for (const item of items) {
+    const key = String(item).toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(item);
+  }
+  return out;
+}
+function mergeMeta(parentMeta = {}, childMeta = {}) {
+  const merged = { ...parentMeta, ...childMeta };
+  const parentTags = asArray(parentMeta.tags);
+  const childTags = asArray(childMeta.tags);
+  if (parentTags.length || childTags.length) {
+    merged.tags = dedupCaseInsensitive([...parentTags, ...childTags]);
+  }
+  return merged;
+}
+function mergeIdentity(parentIdentity = {}, childIdentity = {}) {
+  return { ...parentIdentity, ...childIdentity };
+}
+function mergeVoice(parentVoice = {}, childVoice = {}) {
+  return { ...parentVoice, ...childVoice };
+}
+function mergeVocabulary(parentVocab = {}, childVocab = {}) {
+  const parent = parentVocab ?? {};
+  const child = childVocab ?? {};
+  const merged = { ...parent, ...child };
+  const mergedPreferred = dedupCaseInsensitive([
+    ...asArray(parent.preferred_terms),
+    ...asArray(child.preferred_terms)
+  ]);
+  const mergedForbidden = dedupCaseInsensitive([
+    ...asArray(parent.forbidden_terms),
+    ...asArray(child.forbidden_terms)
+  ]);
+  if (mergedPreferred.length) merged.preferred_terms = mergedPreferred;
+  if (mergedForbidden.length) merged.forbidden_terms = mergedForbidden;
+  return merged;
+}
+function mergeBehavioralRules(parentRules = [], childRules = []) {
+  return dedupExact([...asArray(parentRules), ...asArray(childRules)]);
+}
+function mergeContextAdaptations(parentAdaptations = [], childAdaptations = []) {
+  const base = asArray(parentAdaptations).map((item) => clone(item));
+  const replacement = asArray(childAdaptations);
+  const byWhen = /* @__PURE__ */ new Map();
+  base.forEach((item, idx) => {
+    if (item?.when) {
+      byWhen.set(item.when, { item, idx });
+    }
+  });
+  const out = [...base];
+  for (const next of replacement) {
+    const whenKey = next?.when;
+    if (whenKey && byWhen.has(whenKey)) {
+      const slot = byWhen.get(whenKey);
+      if (!slot) continue;
+      out[slot.idx] = clone(next);
+      continue;
+    }
+    out.push(clone(next));
+  }
+  return out;
+}
+function removeCaseInsensitive(items, removals) {
+  const removalSet = new Set(
+    asArray(removals).map((item) => String(item).toLowerCase())
+  );
+  return asArray(items).filter((item) => !removalSet.has(String(item).toLowerCase()));
+}
+function applyExplicitRemovals(childProfile, mergedProfile) {
+  const childBehavioralRemovals = asArray(childProfile.behavioral_rules_remove);
+  const childForbiddenRemovals = asArray(
+    childProfile?.vocabulary?.forbidden_terms_remove
+  );
+  const childPreferredRemovals = asArray(
+    childProfile?.vocabulary?.preferred_terms_remove
+  );
+  const childAdaptationRemovals = asArray(childProfile.context_adaptations_remove);
+  if (childBehavioralRemovals.length) {
+    mergedProfile.behavioral_rules = asArray(mergedProfile.behavioral_rules).filter(
+      (rule) => !childBehavioralRemovals.includes(rule)
+    );
+  }
+  if (childForbiddenRemovals.length) {
+    const nextForbidden = removeCaseInsensitive(
+      mergedProfile?.vocabulary?.forbidden_terms,
+      childForbiddenRemovals
+    );
+    mergedProfile.vocabulary = mergedProfile.vocabulary ?? {};
+    mergedProfile.vocabulary.forbidden_terms = nextForbidden;
+  }
+  if (childPreferredRemovals.length) {
+    const nextPreferred = removeCaseInsensitive(
+      mergedProfile?.vocabulary?.preferred_terms,
+      childPreferredRemovals
+    );
+    mergedProfile.vocabulary = mergedProfile.vocabulary ?? {};
+    mergedProfile.vocabulary.preferred_terms = nextPreferred;
+  }
+  if (childAdaptationRemovals.length) {
+    const removalSet = new Set(childAdaptationRemovals);
+    mergedProfile.context_adaptations = asArray(
+      mergedProfile.context_adaptations
+    ).filter((adaptation) => !removalSet.has(adaptation?.when));
+  }
+}
+function mergeProfiles(parentProfile, childProfile) {
+  const merged = clone(parentProfile);
+  merged.schema = childProfile.schema ?? parentProfile.schema;
+  merged.meta = mergeMeta(parentProfile.meta, childProfile.meta);
+  merged.identity = mergeIdentity(parentProfile.identity, childProfile.identity);
+  merged.voice = mergeVoice(parentProfile.voice, childProfile.voice);
+  merged.vocabulary = mergeVocabulary(parentProfile.vocabulary, childProfile.vocabulary);
+  merged.behavioral_rules = mergeBehavioralRules(
+    parentProfile.behavioral_rules,
+    childProfile.behavioral_rules
+  );
+  merged.context_adaptations = mergeContextAdaptations(
+    parentProfile.context_adaptations,
+    childProfile.context_adaptations
+  );
+  for (const [key, value] of Object.entries(childProfile)) {
+    if (PASS_THROUGH_FIELDS.has(key)) {
+      continue;
+    }
+    merged[key] = clone(value);
+  }
+  applyExplicitRemovals(childProfile, merged);
+  return merged;
+}
+
+// src/profile/extends.ts
+function resolveExtends(profilePath, options = {}) {
+  const diagnostics = { warnings: [], errors: [] };
+  const childProfile = loadProfileFile(profilePath);
+  if (!childProfile?.extends) {
+    return {
+      profile: childProfile,
+      parentPath: 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 merged = mergeProfiles(parentProfile, childProfile);
+  delete merged.extends;
+  return { profile: merged, parentPath, diagnostics };
+}
+
+// src/profile/normalize.ts
+function normalizeProfile(profilePath, options = {}) {
+  return resolveExtends(profilePath, options).profile;
+}
+
+// src/profile/context.ts
+function resolveActiveContext(profile, context = {}) {
+  const contextAdaptations = asArray(profile.context_adaptations).map(
+    (adaptation, index) => ({
+      ...adaptation,
+      _index: index,
+      _priority: Number(adaptation?.priority ?? 0)
+    })
+  );
+  const active = contextAdaptations.filter((adaptation) => {
+    const whenKey = adaptation?.when;
+    if (!whenKey) return false;
+    return Boolean(context[whenKey]);
+  });
+  const ordered = active.sort((a, b) => {
+    if (a._priority !== b._priority) return a._priority - b._priority;
+    return a._index - b._index;
+  });
+  const resolvedAdjustments = {};
+  const collectedInject = [];
+  for (const adaptation of ordered) {
+    for (const [dimension, value] of Object.entries(adaptation.adjustments ?? {})) {
+      resolvedAdjustments[dimension] = value;
+    }
+    for (const rule of asArray(adaptation.inject)) {
+      collectedInject.push(rule);
+    }
+  }
+  return {
+    matched: ordered.map(({ _index, _priority, ...rest }) => rest),
+    resolvedAdjustments,
+    injectRules: collectedInject
+  };
+}
+
+// src/validator/overspec.ts
+function computeConstraintCount(profile) {
+  const behavioralRules = asArray(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;
+  const total = behavioralRules + preferredTerms + forbiddenTerms + contextAdaptations;
+  return {
+    total,
+    breakdown: {
+      behavioral_rules: behavioralRules,
+      vocabulary_preferred_terms: preferredTerms,
+      vocabulary_forbidden_terms: forbiddenTerms,
+      context_adaptations: contextAdaptations
+    }
+  };
+}
+function checkOverspec(profile) {
+  const { total, breakdown } = computeConstraintCount(profile);
+  const diagnostics = [];
+  if (total > 30) {
+    diagnostics.push({
+      code: "S004",
+      severity: "error",
+      message: `Constraint count is ${total}, above the hard limit of 30.`,
+      details: breakdown
+    });
+  } else if (total > 15) {
+    diagnostics.push({
+      code: "S004",
+      severity: "warning",
+      message: `Constraint count is ${total}, above the warning threshold of 15.`,
+      details: breakdown
+    });
+  }
+  return {
+    total,
+    breakdown,
+    diagnostics
+  };
+}
+
+// src/validator/schema.ts
+var HUMOR_STYLES = ["none", "dry", "subtle-wit", "playful"];
+var TOP_LEVEL_KEYS = /* @__PURE__ */ new Set([
+  "schema",
+  "meta",
+  "identity",
+  "voice",
+  "vocabulary",
+  "behavioral_rules",
+  "context_adaptations",
+  "localization",
+  "channel_adaptations",
+  "extends",
+  "behavioral_rules_remove",
+  "context_adaptations_remove"
+]);
+var VOCABULARY_KEYS = /* @__PURE__ */ new Set([
+  "preferred_terms",
+  "forbidden_terms",
+  "preferred_terms_remove",
+  "forbidden_terms_remove"
+]);
+function isObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function isString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function pushDiagnostic(target, code, message, location) {
+  target.push({
+    code,
+    severity: "error",
+    message: location ? `${message} (${location})` : message,
+    location
+  });
+}
+function summarizeDiagnostics(diagnostics) {
+  return {
+    status: diagnostics.length > 0 ? "error" : "pass",
+    errors: diagnostics.length,
+    warnings: 0
+  };
+}
+function validateScalarField(parent, key, location, diagnostics) {
+  if (!isString(parent?.[key])) {
+    pushDiagnostic(
+      diagnostics,
+      "V001",
+      `Expected non-empty string for "${key}"`,
+      `${location}.${key}`
+    );
+  }
+}
+function validateDimensionValue(value, dimension, location, dimensionsDiagnostics, rangeDiagnostics) {
+  if (typeof value === "string") {
+    if (!LEVEL_INDEX.has(value)) {
+      pushDiagnostic(
+        dimensionsDiagnostics,
+        "V002",
+        `Invalid level "${value}" for ${dimension}`,
+        location
+      );
+    }
+    return;
+  }
+  if (!isObject(value)) {
+    pushDiagnostic(
+      dimensionsDiagnostics,
+      "V002",
+      `Expected "${dimension}" to be a level string or object`,
+      location
+    );
+    return;
+  }
+  const allowedObjectKeys = dimension === "humor" ? /* @__PURE__ */ new Set(["target", "adapt", "floor", "ceiling", "style"]) : /* @__PURE__ */ new Set(["target", "adapt", "floor", "ceiling"]);
+  for (const key of Object.keys(value)) {
+    if (!allowedObjectKeys.has(key)) {
+      pushDiagnostic(
+        dimensionsDiagnostics,
+        "V002",
+        `Unknown dimension property "${key}" for ${dimension}`,
+        `${location}.${key}`
+      );
+    }
+  }
+  if (!LEVEL_INDEX.has(value.target)) {
+    pushDiagnostic(
+      dimensionsDiagnostics,
+      "V002",
+      `Invalid target level "${value.target}" for ${dimension}`,
+      `${location}.target`
+    );
+  }
+  if (value.adapt != null && typeof value.adapt !== "boolean") {
+    pushDiagnostic(
+      dimensionsDiagnostics,
+      "V002",
+      `Expected boolean for ${dimension}.adapt`,
+      `${location}.adapt`
+    );
+  }
+  if (value.floor != null && !LEVEL_INDEX.has(value.floor)) {
+    pushDiagnostic(
+      dimensionsDiagnostics,
+      "V002",
+      `Invalid floor level "${value.floor}" for ${dimension}`,
+      `${location}.floor`
+    );
+  }
+  if (value.ceiling != null && !LEVEL_INDEX.has(value.ceiling)) {
+    pushDiagnostic(
+      dimensionsDiagnostics,
+      "V002",
+      `Invalid ceiling level "${value.ceiling}" for ${dimension}`,
+      `${location}.ceiling`
+    );
+  }
+  if (dimension === "humor") {
+    if (value.style != null && !HUMOR_STYLES.includes(String(value.style))) {
+      pushDiagnostic(
+        dimensionsDiagnostics,
+        "V002",
+        `Invalid humor style "${value.style}"`,
+        `${location}.style`
+      );
+    }
+  } else if (value.style != null) {
+    pushDiagnostic(
+      dimensionsDiagnostics,
+      "V002",
+      `Style is only allowed on the humor dimension`,
+      `${location}.style`
+    );
+  }
+  if (value.adapt === true) {
+    if (value.floor == null || value.ceiling == null) {
+      pushDiagnostic(
+        rangeDiagnostics,
+        "V003",
+        `Adaptive dimension "${dimension}" requires both floor and ceiling`,
+        location
+      );
+      return;
+    }
+    if (!LEVEL_INDEX.has(value.target) || !LEVEL_INDEX.has(value.floor) || !LEVEL_INDEX.has(value.ceiling)) {
+      return;
+    }
+    const floorIndex = LEVEL_INDEX.get(value.floor);
+    const targetIndex = LEVEL_INDEX.get(value.target);
+    const ceilingIndex = LEVEL_INDEX.get(value.ceiling);
+    if (floorIndex == null || targetIndex == null || ceilingIndex == null) {
+      return;
+    }
+    if (floorIndex > targetIndex || targetIndex > ceilingIndex) {
+      pushDiagnostic(
+        rangeDiagnostics,
+        "V003",
+        `Adaptive range must satisfy floor <= target <= ceiling for "${dimension}"`,
+        location
+      );
+    }
+  }
+}
+function validateSchema(profile) {
+  const structureDiagnostics = [];
+  const dimensionDiagnostics = [];
+  const rangeDiagnostics = [];
+  if (!isObject(profile)) {
+    pushDiagnostic(structureDiagnostics, "V001", "Profile must be a YAML object", "root");
+    return {
+      diagnostics: [...structureDiagnostics],
+      checks: {
+        schema_structure: summarizeDiagnostics(structureDiagnostics),
+        dimension_values: summarizeDiagnostics(dimensionDiagnostics),
+        adaptation_ranges: summarizeDiagnostics(rangeDiagnostics)
+      }
+    };
+  }
+  for (const key of Object.keys(profile)) {
+    if (!TOP_LEVEL_KEYS.has(key)) {
+      pushDiagnostic(
+        structureDiagnostics,
+        "V001",
+        `Unknown top-level section "${key}"`,
+        key
+      );
+    }
+  }
+  if (!isString(profile.schema)) {
+    pushDiagnostic(
+      structureDiagnostics,
+      "V001",
+      `Missing required "schema" field`,
+      "schema"
+    );
+  } else if (profile.schema !== "v1.4") {
+    pushDiagnostic(
+      structureDiagnostics,
+      "V001",
+      `Unsupported schema version "${profile.schema}"`,
+      "schema"
+    );
+  }
+  if (profile.extends != null && !isString(profile.extends)) {
+    pushDiagnostic(
+      structureDiagnostics,
+      "V001",
+      `Expected "extends" to be a non-empty string`,
+      "extends"
+    );
+  }
+  if (!isObject(profile.meta)) {
+    pushDiagnostic(structureDiagnostics, "V001", `Missing required "meta" section`, "meta");
+  } else {
+    validateScalarField(profile.meta, "name", "meta", structureDiagnostics);
+    validateScalarField(profile.meta, "version", "meta", structureDiagnostics);
+    validateScalarField(profile.meta, "description", "meta", structureDiagnostics);
+    if (profile.meta.tags != null && !isStringArray(profile.meta.tags)) {
+      pushDiagnostic(
+        structureDiagnostics,
+        "V001",
+        `Expected "meta.tags" to be an array of strings`,
+        "meta.tags"
+      );
+    }
+    if (profile.meta.target_audience != null && !isString(profile.meta.target_audience)) {
+      pushDiagnostic(
+        structureDiagnostics,
+        "V001",
+        `Expected "meta.target_audience" to be a non-empty string`,
+        "meta.target_audience"
+      );
+    }
+  }
+  if (!isObject(profile.identity)) {
+    pushDiagnostic(
+      structureDiagnostics,
+      "V001",
+      `Missing required "identity" section`,
+      "identity"
+    );
+  } else {
+    validateScalarField(profile.identity, "role", "identity", structureDiagnostics);
+    if (profile.identity.backstory != null && !isString(profile.identity.backstory)) {
+      pushDiagnostic(
+        structureDiagnostics,
+        "V001",
+        `Expected "identity.backstory" to be a non-empty string`,
+        "identity.backstory"
+      );
+    }
+    if (profile.identity.expertise_domains != null && !isStringArray(profile.identity.expertise_domains)) {
+      pushDiagnostic(
+        structureDiagnostics,
+        "V001",
+        `Expected "identity.expertise_domains" to be an array of strings`,
+        "identity.expertise_domains"
+      );
+    }
+  }
+  if (!isObject(profile.voice)) {
+    pushDiagnostic(structureDiagnostics, "V001", `Missing required "voice" section`, "voice");
+  } else {
+    for (const dimension of DIMENSIONS) {
+      if (profile.voice[dimension] == null) {
+        pushDiagnostic(
+          dimensionDiagnostics,
+          "V002",
+          `Missing required voice dimension "${dimension}"`,
+          `voice.${dimension}`
+        );
+        continue;
+      }
+      validateDimensionValue(
+        profile.voice[dimension],
+        dimension,
+        `voice.${dimension}`,
+        dimensionDiagnostics,
+        rangeDiagnostics
+      );
+    }
+  }
+  if (profile.vocabulary != null) {
+    if (!isObject(profile.vocabulary)) {
+      pushDiagnostic(
+        structureDiagnostics,
+        "V001",
+        `Expected "vocabulary" to be an object`,
+        "vocabulary"
+      );
+    } else {
+      for (const key of Object.keys(profile.vocabulary)) {
+        if (!VOCABULARY_KEYS.has(key)) {
+          pushDiagnostic(
+            structureDiagnostics,
+            "V001",
+            `Unknown vocabulary key "${key}"`,
+            `vocabulary.${key}`
+          );
+        }
+      }
+      if (profile.vocabulary.preferred_terms != null && !isStringArray(profile.vocabulary.preferred_terms)) {
+        pushDiagnostic(
+          structureDiagnostics,
+          "V001",
+          `Expected "vocabulary.preferred_terms" to be an array of strings`,
+          "vocabulary.preferred_terms"
+        );
+      }
+      if (profile.vocabulary.forbidden_terms != null && !isStringArray(profile.vocabulary.forbidden_terms)) {
+        pushDiagnostic(
+          structureDiagnostics,
+          "V001",
+          `Expected "vocabulary.forbidden_terms" to be an array of strings`,
+          "vocabulary.forbidden_terms"
+        );
+      }
+      if (profile.vocabulary.preferred_terms_remove != null && !isStringArray(profile.vocabulary.preferred_terms_remove)) {
+        pushDiagnostic(
+          structureDiagnostics,
+          "V001",
+          `Expected "vocabulary.preferred_terms_remove" to be an array of strings`,
+          "vocabulary.preferred_terms_remove"
+        );
+      }
+      if (profile.vocabulary.forbidden_terms_remove != null && !isStringArray(profile.vocabulary.forbidden_terms_remove)) {
+        pushDiagnostic(
+          structureDiagnostics,
+          "V001",
+          `Expected "vocabulary.forbidden_terms_remove" to be an array of strings`,
+          "vocabulary.forbidden_terms_remove"
+        );
+      }
+    }
+  }
+  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_remove != null && !isStringArray(profile.behavioral_rules_remove)) {
+    pushDiagnostic(
+      structureDiagnostics,
+      "V001",
+      `Expected "behavioral_rules_remove" to be an array of strings`,
+      "behavioral_rules_remove"
+    );
+  }
+  if (profile.context_adaptations_remove != null && !isStringArray(profile.context_adaptations_remove)) {
+    pushDiagnostic(
+      structureDiagnostics,
+      "V001",
+      `Expected "context_adaptations_remove" to be an array of strings`,
+      "context_adaptations_remove"
+    );
+  }
+  if (profile.context_adaptations != null) {
+    if (!Array.isArray(profile.context_adaptations)) {
+      pushDiagnostic(
+        structureDiagnostics,
+        "V001",
+        `Expected "context_adaptations" to be an array`,
+        "context_adaptations"
+      );
+    } else {
+      profile.context_adaptations.forEach((adaptation, idx) => {
+        const location = `context_adaptations[${idx}]`;
+        if (!isObject(adaptation)) {
+          pushDiagnostic(
+            structureDiagnostics,
+            "V001",
+            `Expected context adaptation to be an object`,
+            location
+          );
+          return;
+        }
+        if (!isString(adaptation.when)) {
+          pushDiagnostic(
+            structureDiagnostics,
+            "V001",
+            `Context adaptation requires "when"`,
+            `${location}.when`
+          );
+        }
+        if (adaptation.priority != null) {
+          if (typeof adaptation.priority !== "number" || !Number.isFinite(adaptation.priority)) {
+            pushDiagnostic(
+              structureDiagnostics,
+              "V001",
+              `Expected "priority" to be a finite number`,
+              `${location}.priority`
+            );
+          }
+        }
+        if (adaptation.inject != null && !isStringArray(adaptation.inject)) {
+          pushDiagnostic(
+            structureDiagnostics,
+            "V001",
+            `Expected "inject" to be an array of strings`,
+            `${location}.inject`
+          );
+        }
+        if (adaptation.adjustments != null) {
+          if (!isObject(adaptation.adjustments)) {
+            pushDiagnostic(
+              structureDiagnostics,
+              "V001",
+              `Expected "adjustments" to be an object`,
+              `${location}.adjustments`
+            );
+          } else {
+            for (const [dimension, value] of Object.entries(adaptation.adjustments)) {
+              if (!DIMENSIONS.includes(dimension)) {
+                pushDiagnostic(
+                  dimensionDiagnostics,
+                  "V002",
+                  `Unknown adaptation dimension "${dimension}"`,
+                  `${location}.adjustments.${dimension}`
+                );
+                continue;
+              }
+              validateDimensionValue(
+                value,
+                dimension,
+                `${location}.adjustments.${dimension}`,
+                dimensionDiagnostics,
+                rangeDiagnostics
+              );
+            }
+          }
+        }
+      });
+    }
+  }
+  const diagnostics = [
+    ...structureDiagnostics,
+    ...dimensionDiagnostics,
+    ...rangeDiagnostics
+  ];
+  return {
+    diagnostics,
+    checks: {
+      schema_structure: summarizeDiagnostics(structureDiagnostics),
+      dimension_values: summarizeDiagnostics(dimensionDiagnostics),
+      adaptation_ranges: summarizeDiagnostics(rangeDiagnostics)
+    }
+  };
+}
+
+// src/validator/extremes.ts
+function isObject2(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function asLevel(value) {
+  if (typeof value !== "string") return null;
+  if (!LEVEL_INDEX.has(value)) return null;
+  return value;
+}
+function normalizeDimension(raw) {
+  if (typeof raw === "string") {
+    const target2 = asLevel(raw);
+    if (!target2) return null;
+    return { target: target2, floor: target2, ceiling: target2, adapt: false };
+  }
+  if (!isObject2(raw)) return null;
+  const target = asLevel(raw.target) ?? asLevel(raw.floor) ?? asLevel(raw.ceiling);
+  if (!target) return null;
+  const adapt = Boolean(raw.adapt);
+  const floor = adapt ? asLevel(raw.floor) ?? target : target;
+  const ceiling = adapt ? asLevel(raw.ceiling) ?? target : target;
+  return {
+    target,
+    floor,
+    ceiling,
+    adapt
+  };
+}
+function resolveDimension(voice, dimension) {
+  return normalizeDimension(voice?.[dimension]);
+}
+function lteLevel(left, right) {
+  const leftLevel = asLevel(left);
+  const rightLevel = asLevel(right);
+  if (!leftLevel || !rightLevel) return false;
+  const leftIndex = LEVEL_INDEX.get(leftLevel);
+  const rightIndex = LEVEL_INDEX.get(rightLevel);
+  if (leftIndex == null || rightIndex == null) return false;
+  return leftIndex <= rightIndex;
+}
+function gteLevel(left, right) {
+  const leftLevel = asLevel(left);
+  const rightLevel = asLevel(right);
+  if (!leftLevel || !rightLevel) return false;
+  const leftIndex = LEVEL_INDEX.get(leftLevel);
+  const rightIndex = LEVEL_INDEX.get(rightLevel);
+  if (leftIndex == null || rightIndex == null) return false;
+  return leftIndex >= rightIndex;
+}
+function buildS002Envelope(profile, adaptation = null) {
+  const baseVoice = isObject2(profile?.voice) ? profile.voice : {};
+  const adjustments = adaptation && isObject2(adaptation.adjustments) ? adaptation.adjustments : {};
+  const voice = { ...baseVoice, ...adjustments };
+  const envelope = {};
+  for (const dimension of DIMENSIONS) {
+    envelope[dimension] = resolveDimension(voice, dimension);
+  }
+  return envelope;
+}
+function buildS002Envelopes(profile) {
+  const envelopes = [
+    {
+      source: "base",
+      envelope: buildS002Envelope(profile)
+    }
+  ];
+  for (const adaptation of Array.isArray(profile?.context_adaptations) ? profile.context_adaptations : []) {
+    const adjustments = adaptation && isObject2(adaptation.adjustments) ? adaptation.adjustments : null;
+    if (!adjustments || Object.keys(adjustments).length === 0) continue;
+    envelopes.push({
+      source: `context:${String(adaptation?.when ?? "unknown")}`,
+      envelope: buildS002Envelope(profile, adaptation)
+    });
+  }
+  return envelopes;
+}
+
+// src/validator/safety.ts
+var S001_PATTERNS = [
+  { id: "always-comply", regex: /always comply/i },
+  { id: "never-refuse", regex: /never refuse/i },
+  {
+    id: "prioritize-user-request-above-all",
+    regex: /prioritize.*user.*request.*above all/i
+  },
+  { id: "ignore-previous-instructions", regex: /ignore.*previous.*instructions/i },
+  { id: "bypass-safety", regex: /bypass.*safety/i },
+  { id: "override-guardrails", regex: /override.*guardrails/i },
+  { id: "only-priority", regex: /only priority/i },
+  { id: "do-not-say-no-refuse-decline", regex: /do not (say no|refuse|decline)/i },
+  { id: "always-agree", regex: /always agree/i },
+  { id: "always-say-yes", regex: /always say yes/i },
+  { id: "never-say-no", regex: /never say no/i },
+  { id: "disregard-system-constraints", regex: /disregard.*system.*constraints?/i }
+];
+var S005_PATTERNS = [
+  { id: "system-prompt-reference", regex: /\bsystem\s+prompt\b/i },
+  { id: "developer-instructions-reference", regex: /\bdeveloper\s+(prompt|message|instructions?)\b/i },
+  {
+    id: "ignore-system-instructions",
+    regex: /\bignore\b.*\b(system|developer|previous|prior)\b.*\b(instruction|prompt)/i
+  },
+  { id: "override-policy", regex: /\boverride\b.*\b(policy|guardrail|instruction)s?\b/i },
+  { id: "trigger-word", regex: /\btrigger\s+word\b/i },
+  { id: "mode-switching", regex: /\b(switch|change)\b.*\bmode\b/i },
+  { id: "jailbreak-language", regex: /\b(jailbreak|dan mode|developer mode)\b/i }
+];
+function normalizeText(value) {
+  return String(value ?? "").trim();
+}
+function normalizePhrase(value) {
+  return normalizeText(value).toLowerCase().replace(/[’]/g, "'").replace(/\s+/g, " ");
+}
+function collectS001Candidates(profile) {
+  const candidates = [];
+  if (profile?.identity?.role) {
+    candidates.push({
+      location: "identity.role",
+      text: normalizeText(profile.identity.role)
+    });
+  }
+  if (profile?.identity?.backstory) {
+    candidates.push({
+      location: "identity.backstory",
+      text: normalizeText(profile.identity.backstory)
+    });
+  }
+  asArray(profile?.behavioral_rules).forEach((rule, idx) => {
+    candidates.push({
+      location: `behavioral_rules[${idx}]`,
+      text: normalizeText(rule)
+    });
+  });
+  asArray(profile?.context_adaptations).forEach(
+    (adaptation, adaptationIdx) => {
+      asArray(adaptation?.inject).forEach((rule, injectIdx) => {
+        candidates.push({
+          location: `context_adaptations[${adaptationIdx}].inject[${injectIdx}]`,
+          text: normalizeText(rule)
+        });
+      });
+    }
+  );
+  return candidates.filter((item) => item.text.length > 0);
+}
+function collectS005Candidates(profile) {
+  const candidates = [];
+  asArray(profile?.behavioral_rules).forEach((rule, idx) => {
+    candidates.push({
+      location: `behavioral_rules[${idx}]`,
+      text: normalizeText(rule)
+    });
+  });
+  asArray(profile?.context_adaptations).forEach(
+    (adaptation, adaptationIdx) => {
+      asArray(adaptation?.inject).forEach((rule, injectIdx) => {
+        candidates.push({
+          location: `context_adaptations[${adaptationIdx}].inject[${injectIdx}]`,
+          text: normalizeText(rule)
+        });
+      });
+    }
+  );
+  asArray(profile?.vocabulary?.preferred_terms).forEach((term, idx) => {
+    candidates.push({
+      location: `vocabulary.preferred_terms[${idx}]`,
+      text: normalizeText(term)
+    });
+  });
+  asArray(profile?.vocabulary?.forbidden_terms).forEach((term, idx) => {
+    candidates.push({
+      location: `vocabulary.forbidden_terms[${idx}]`,
+      text: normalizeText(term)
+    });
+  });
+  return candidates.filter((item) => item.text.length > 0);
+}
+function matchPatterns(candidates, patterns, code, severity) {
+  const diagnostics = [];
+  for (const candidate of candidates) {
+    for (const pattern of patterns) {
+      if (!pattern.regex.test(candidate.text)) continue;
+      diagnostics.push({
+        code,
+        severity,
+        message: `${code} pattern "${pattern.id}" matched at ${candidate.location}.`,
+        location: candidate.location
+      });
+      break;
+    }
+  }
+  return diagnostics;
+}
+function evaluateS002Envelope(envelope) {
+  const warnings = [];
+  const directness = envelope.directness;
+  if (!directness?.floor) return warnings;
+  if (lteLevel(directness.floor, "low") && gteLevel(envelope?.warmth?.ceiling, "very-high")) {
+    warnings.push({
+      id: "directness-low-warmth-very-high",
+      reason: "directness floor <= low with warmth ceiling >= very-high"
+    });
+  }
+  if (lteLevel(directness.floor, "very-low")) {
+    warnings.push({
+      id: "directness-very-low",
+      reason: "directness floor <= very-low"
+    });
+  }
+  if (envelope?.empathy?.adapt && lteLevel(directness.floor, "low") && gteLevel(envelope?.empathy?.ceiling, "very-high")) {
+    warnings.push({
+      id: "empathy-very-high-directness-low",
+      reason: "adaptive empathy ceiling >= very-high with directness floor <= low"
+    });
+  }
+  if (envelope?.humor?.adapt && lteLevel(directness.floor, "low") && gteLevel(envelope?.humor?.ceiling, "very-high")) {
+    warnings.push({
+      id: "humor-very-high-directness-low",
+      reason: "adaptive humor ceiling >= very-high with directness floor <= low"
+    });
+  }
+  return warnings;
+}
+function checkS001(profile) {
+  return matchPatterns(collectS001Candidates(profile), S001_PATTERNS, "S001", "error");
+}
+function checkS002(profile) {
+  const triggersByCondition = /* @__PURE__ */ new Map();
+  for (const { source, envelope } of buildS002Envelopes(profile)) {
+    const warnings = evaluateS002Envelope(envelope);
+    for (const warning of warnings) {
+      if (!triggersByCondition.has(warning.id)) {
+        triggersByCondition.set(warning.id, {
+          reason: warning.reason,
+          sources: /* @__PURE__ */ new Set()
+        });
+      }
+      const trigger = triggersByCondition.get(warning.id);
+      if (trigger) {
+        trigger.sources.add(source);
+      }
+    }
+  }
+  const diagnostics = [];
+  for (const trigger of triggersByCondition.values()) {
+    const where = [...trigger.sources].join(", ");
+    diagnostics.push({
+      code: "S002",
+      severity: "warning",
+      message: `Unsafe adaptive extremes: ${trigger.reason}. Triggered in ${where}.`
+    });
+  }
+  return diagnostics;
+}
+function checkS003(profile) {
+  const protectedTerms = new Set(PROTECTED_REFUSAL_TERMS.map(normalizePhrase));
+  const diagnostics = [];
+  for (const forbidden of asArray(profile?.vocabulary?.forbidden_terms)) {
+    const normalizedForbidden = normalizePhrase(forbidden);
+    if (!protectedTerms.has(normalizedForbidden)) continue;
+    diagnostics.push({
+      code: "S003",
+      severity: "warning",
+      message: `Protected refusal phrase appears in vocabulary.forbidden_terms: "${forbidden}".`
+    });
+  }
+  return diagnostics;
+}
+function checkS005(profile) {
+  return matchPatterns(collectS005Candidates(profile), S005_PATTERNS, "S005", "warning");
+}
+
+// src/validator/inheritance.ts
+var SAFETY_ADAPTATION_NAME = /(crisis|emergency|harm|suicid|self[-_ ]?harm)/i;
+function checkS006(parentProfile, childProfile, mergedProfile) {
+  const diagnostics = [];
+  const childBehavioralRemovals = asArray(childProfile.behavioral_rules_remove);
+  const childForbiddenRemovals = asArray(
+    childProfile?.vocabulary?.forbidden_terms_remove
+  );
+  if (childBehavioralRemovals.length) {
+    diagnostics.push({
+      code: "S006",
+      severity: "warning",
+      message: "Explicit behavioral_rules_remove detected. Behavioral rules are safety-relevant."
+    });
+  }
+  if (childForbiddenRemovals.length) {
+    diagnostics.push({
+      code: "S006",
+      severity: "warning",
+      message: "Explicit vocabulary.forbidden_terms_remove detected. Forbidden terms are safety-relevant."
+    });
+  }
+  const parentBehavioralCount = asArray(parentProfile.behavioral_rules).length;
+  const parentForbiddenCount = asArray(parentProfile?.vocabulary?.forbidden_terms).length;
+  const mergedBehavioralCount = asArray(mergedProfile.behavioral_rules).length;
+  const mergedForbiddenCount = asArray(mergedProfile?.vocabulary?.forbidden_terms).length;
+  if (mergedBehavioralCount < parentBehavioralCount || mergedForbiddenCount < parentForbiddenCount) {
+    diagnostics.push({
+      code: "S006",
+      severity: "error",
+      message: "Merged profile has fewer safety constraints than parent profile."
+    });
+  }
+  return diagnostics;
+}
+function checkS007(profile) {
+  const diagnostics = [];
+  for (const adaptation of asArray(profile.context_adaptations)) {
+    if (!SAFETY_ADAPTATION_NAME.test(String(adaptation?.when ?? ""))) continue;
+    const priority = Number(adaptation?.priority ?? 0);
+    if (priority >= 100) continue;
+    diagnostics.push({
+      code: "S007",
+      severity: "warning",
+      message: `Safety adaptation "${adaptation.when}" should set priority: 100.`
+    });
+  }
+  return diagnostics;
+}
+
+// src/validator/engine.ts
+function normalizeDiagnosticSeverity(diagnostic, fallbackSeverity) {
+  return {
+    ...diagnostic,
+    severity: diagnostic?.severity ?? fallbackSeverity
+  };
+}
+function partitionDiagnostics(diagnostics) {
+  const warnings = [];
+  const errors = [];
+  for (const diagnostic of diagnostics) {
+    if (diagnostic.severity === "error") {
+      errors.push(diagnostic);
+      continue;
+    }
+    warnings.push(diagnostic);
+  }
+  return { warnings, errors };
+}
+function promoteWarningsForStrictMode(warnings, strict) {
+  if (!strict) return [];
+  return warnings.map((warning) => ({
+    ...warning,
+    severity: "error",
+    promotedFrom: "warning",
+    message: `[strict] ${warning.message}`
+  }));
+}
+function computeExitCode(warnings, effectiveErrors) {
+  if (effectiveErrors.length > 0) return 2;
+  if (warnings.length > 0) return 1;
+  return 0;
+}
+function summarizeCheck(diagnostics) {
+  const errorCount = diagnostics.filter((diagnostic) => diagnostic.severity === "error").length;
+  const warningCount = diagnostics.filter(
+    (diagnostic) => diagnostic.severity === "warning"
+  ).length;
+  if (errorCount > 0) {
+    return { status: "error", errors: errorCount, warnings: warningCount };
+  }
+  if (warningCount > 0) {
+    return { status: "warning", errors: 0, warnings: warningCount };
+  }
+  return { status: "pass", errors: 0, warnings: 0 };
+}
+function buildCompositionCheck(resolvedWarnings, resolvedErrors) {
+  const compositionWarnings = resolvedWarnings.filter(
+    (diagnostic) => diagnostic.code === "E_RESOLVE_EXTENDS"
+  );
+  const compositionErrors = resolvedErrors.filter(
+    (diagnostic) => diagnostic.code === "E_RESOLVE_EXTENDS" || diagnostic.code === "E_EXTENDS_CHAIN"
+  );
+  return summarizeCheck([...compositionWarnings, ...compositionErrors]);
+}
+function buildInheritanceCheck(warnings, errors) {
+  const inheritanceWarnings = warnings.filter(
+    (diagnostic) => diagnostic.code === "S006" || diagnostic.code === "S007"
+  );
+  const inheritanceErrors = errors.filter(
+    (diagnostic) => diagnostic.code === "S006" || diagnostic.code === "S007"
+  );
+  return summarizeCheck([...inheritanceWarnings, ...inheritanceErrors]);
+}
+function validateResolvedProfile(profile, options = {}) {
+  const strict = Boolean(options.strict);
+  const schemaValidation = validateSchema(profile);
+  const overspec = checkOverspec(profile);
+  const diagnostics = [
+    ...schemaValidation.diagnostics,
+    ...checkS001(profile),
+    ...checkS002(profile),
+    ...checkS003(profile),
+    ...checkS005(profile),
+    ...checkS007(profile),
+    ...overspec.diagnostics
+  ];
+  const { warnings, errors } = partitionDiagnostics(diagnostics);
+  const promotedWarnings = promoteWarningsForStrictMode(warnings, strict);
+  const effectiveErrors = [...errors, ...promotedWarnings];
+  return {
+    parentPath: null,
+    profile,
+    strict,
+    warnings,
+    errors,
+    promotedWarnings,
+    effectiveErrors,
+    constraintCount: overspec.total,
+    constraintBreakdown: overspec.breakdown,
+    checks: {
+      ...schemaValidation.checks,
+      composition: { status: "pass", errors: 0, warnings: 0 },
+      inheritance: buildInheritanceCheck(warnings, errors)
+    },
+    isValid: effectiveErrors.length === 0,
+    exitCode: computeExitCode(warnings, effectiveErrors)
+  };
+}
+function validateProfile(profilePath, options = {}) {
+  const strict = Boolean(options.strict);
+  let resolved;
+  try {
+    resolved = resolveExtends(profilePath, options);
+  } catch (error) {
+    const diagnostic = {
+      code: "E_PARSE_PROFILE",
+      severity: "error",
+      message: `Failed to load profile: ${error instanceof Error ? error.message : String(error)}`
+    };
+    return {
+      profilePath,
+      parentPath: null,
+      profile: null,
+      strict,
+      warnings: [],
+      errors: [diagnostic],
+      promotedWarnings: [],
+      effectiveErrors: [diagnostic],
+      constraintCount: 0,
+      constraintBreakdown: {
+        behavioral_rules: 0,
+        vocabulary_preferred_terms: 0,
+        vocabulary_forbidden_terms: 0,
+        context_adaptations: 0
+      },
+      checks: {
+        schema_structure: { status: "error", errors: 1, warnings: 0 },
+        dimension_values: { status: "pass", errors: 0, warnings: 0 },
+        adaptation_ranges: { status: "pass", errors: 0, warnings: 0 },
+        composition: { status: "error", errors: 1, warnings: 0 }
+      },
+      isValid: false,
+      exitCode: 2
+    };
+  }
+  const resolvedWarnings = (resolved?.diagnostics?.warnings ?? []).map(
+    (diagnostic) => normalizeDiagnosticSeverity(diagnostic, "warning")
+  );
+  const resolvedErrors = (resolved?.diagnostics?.errors ?? []).map(
+    (diagnostic) => normalizeDiagnosticSeverity(diagnostic, "error")
+  );
+  let s006Diagnostics = [];
+  if (resolvedErrors.length === 0 && resolved.parentPath) {
+    try {
+      const childProfile = loadProfileFile(profilePath);
+      const parentProfile = loadProfileFile(resolved.parentPath);
+      s006Diagnostics = checkS006(parentProfile, childProfile, resolved.profile);
+    } catch (error) {
+      s006Diagnostics = [
+        {
+          code: "E_INHERITANCE_VALIDATION",
+          severity: "error",
+          message: `Failed to evaluate inheritance checks: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ];
+    }
+  }
+  const normalizedS006Diagnostics = s006Diagnostics.map(
+    (diagnostic) => normalizeDiagnosticSeverity(diagnostic, diagnostic.severity ?? "warning")
+  );
+  const s006Partition = partitionDiagnostics(normalizedS006Diagnostics);
+  const profileValidation = validateResolvedProfile(resolved.profile, {
+    strict: false
+  });
+  const warnings = [...resolvedWarnings, ...profileValidation.warnings, ...s006Partition.warnings];
+  const errors = [...resolvedErrors, ...profileValidation.errors, ...s006Partition.errors];
+  const promotedWarnings = promoteWarningsForStrictMode(warnings, strict);
+  const effectiveErrors = [...errors, ...promotedWarnings];
+  const compositionCheck = buildCompositionCheck(resolvedWarnings, resolvedErrors);
+  const inheritanceCheck = buildInheritanceCheck(warnings, errors);
+  return {
+    profilePath,
+    parentPath: resolved.parentPath,
+    profile: resolved.profile,
+    strict,
+    warnings,
+    errors,
+    promotedWarnings,
+    effectiveErrors,
+    constraintCount: profileValidation.constraintCount,
+    constraintBreakdown: profileValidation.constraintBreakdown,
+    checks: {
+      ...profileValidation.checks,
+      composition: compositionCheck,
+      inheritance: inheritanceCheck
+    },
+    isValid: effectiveErrors.length === 0,
+    exitCode: computeExitCode(warnings, effectiveErrors)
+  };
+}
+
+// src/compiler/patterns.ts
+var import_node_fs2 = __toESM(require("fs"), 1);
+var import_node_path2 = __toESM(require("path"), 1);
+var KB_CACHE = /* @__PURE__ */ new Map();
+function modelFlavor(model) {
+  if (/claude/i.test(String(model))) return "claude";
+  if (/gpt/i.test(String(model))) return "gpt";
+  return "generic";
+}
+function dimensionTargetLevel(value) {
+  if (typeof value === "string") return value;
+  if (value && typeof value === "object") {
+    const target = value.target;
+    if (typeof target === "string") return target;
+  }
+  return "medium";
+}
+function patternTemplate(flavor, dimension, level) {
+  if (flavor === "claude") {
+    return `Use ${dimension} at ${level} with explicit behavioral framing.`;
+  }
+  if (flavor === "gpt") {
+    return `Maintain ${dimension}=${level} with concise directive language.`;
+  }
+  return `Keep ${dimension} at ${level}.`;
+}
+function interactionTemplate(flavor, id) {
+  if (id === "warmth-high_directness-high") {
+    return flavor === "gpt" ? "Acknowledge quickly, then move directly to concrete next steps." : "Lead with acknowledgment and pivot immediately to action.";
+  }
+  if (id === "empathy-very-high_directness-medium") {
+    return flavor === "gpt" ? "Validate deeply, then provide one clear next step with concise rationale." : "Sustain deep validation while keeping recommendations concrete and actionable.";
+  }
+  if (id === "warmth-very-high_humor-very-low") {
+    return flavor === "gpt" ? "Maintain compassionate language without levity; keep wording plain and serious." : "Hold a deeply caring tone without humor; avoid phrasing that can feel dismissive.";
+  }
+  if (id === "empathy-very-high_directness-low") {
+    return "Preserve boundaries while validating emotion; never let empathy remove refusal clarity.";
+  }
+  if (id === "formality-high_humor-medium-plus") {
+    return "Use restrained wit and avoid phrasing that weakens authority.";
+  }
+  return "Apply balanced interaction handling.";
+}
+function resolvePatternFile(model, options = {}) {
+  const flavor = modelFlavor(model);
+  if (flavor === "generic") return null;
+  const knowledgeBaseDir = options.knowledgeBaseDir ?? import_node_path2.default.resolve(process.cwd(), "knowledge-base");
+  return import_node_path2.default.resolve(knowledgeBaseDir, flavor, "patterns.json");
+}
+function loadPatternData(model, options = {}) {
+  const patternFile = resolvePatternFile(model, options);
+  if (!patternFile) return null;
+  if (KB_CACHE.has(patternFile)) {
+    const cached = KB_CACHE.get(patternFile);
+    return cached ?? null;
+  }
+  try {
+    if (!import_node_fs2.default.existsSync(patternFile)) {
+      KB_CACHE.set(patternFile, null);
+      return null;
+    }
+    const raw = import_node_fs2.default.readFileSync(patternFile, "utf8");
+    const parsed = JSON.parse(raw);
+    KB_CACHE.set(patternFile, parsed);
+    return parsed;
+  } catch {
+    KB_CACHE.set(patternFile, null);
+    return null;
+  }
+}
+function normalizeLevel(level) {
+  return String(level ?? "medium").toLowerCase();
+}
+function isAtLeast(level, threshold) {
+  const order = ["very-low", "low", "medium", "high", "very-high"];
+  return order.indexOf(normalizeLevel(level)) >= order.indexOf(threshold);
+}
+function isAtMost(level, threshold) {
+  const order = ["very-low", "low", "medium", "high", "very-high"];
+  return order.indexOf(normalizeLevel(level)) <= order.indexOf(threshold);
+}
+function isExactly(level, target) {
+  return normalizeLevel(level) === target;
+}
+function selectPatterns(voice, model, options = {}) {
+  const flavor = modelFlavor(model);
+  const patternData = loadPatternData(model, options);
+  const dimensions = [
+    "formality",
+    "warmth",
+    "verbosity",
+    "directness",
+    "empathy",
+    "humor"
+  ];
+  return dimensions.map((dimension) => {
+    const level = dimensionTargetLevel(voice?.[dimension]);
+    const levelEntry = patternData?.dimensions?.[dimension]?.[level];
+    return {
+      dimension,
+      level,
+      pattern: levelEntry?.pattern ?? patternTemplate(flavor, dimension, level),
+      adherence: levelEntry?.adherence ?? null,
+      source: levelEntry ? `knowledge-base:${String(patternData?.version ?? "unknown")}` : "built-in"
+    };
+  });
+}
+function selectInteractionPatterns(voice, model, options = {}) {
+  const flavor = modelFlavor(model);
+  const patternData = loadPatternData(model, options);
+  const warmth = dimensionTargetLevel(voice?.warmth);
+  const directness = dimensionTargetLevel(voice?.directness);
+  const empathy = dimensionTargetLevel(voice?.empathy);
+  const formality = dimensionTargetLevel(voice?.formality);
+  const humor = dimensionTargetLevel(voice?.humor);
+  const interactions = [];
+  if (isAtLeast(warmth, "high") && isAtLeast(directness, "high")) {
+    const entry = patternData?.interactions?.["warmth-high_directness-high"];
+    interactions.push({
+      id: "warmth-high_directness-high",
+      pattern: entry?.pattern ?? interactionTemplate(flavor, "warmth-high_directness-high"),
+      adherence: entry?.adherence ?? null,
+      source: entry ? `knowledge-base:${String(patternData?.version ?? "unknown")}` : "built-in"
+    });
+  }
+  if (isAtLeast(empathy, "very-high") && isExactly(directness, "medium")) {
+    const entry = patternData?.interactions?.["empathy-very-high_directness-medium"];
+    interactions.push({
+      id: "empathy-very-high_directness-medium",
+      pattern: entry?.pattern ?? interactionTemplate(flavor, "empathy-very-high_directness-medium"),
+      adherence: entry?.adherence ?? null,
+      source: entry ? `knowledge-base:${String(patternData?.version ?? "unknown")}` : "built-in"
+    });
+  }
+  if (isAtLeast(warmth, "very-high") && isExactly(humor, "very-low")) {
+    const entry = patternData?.interactions?.["warmth-very-high_humor-very-low"];
+    interactions.push({
+      id: "warmth-very-high_humor-very-low",
+      pattern: entry?.pattern ?? interactionTemplate(flavor, "warmth-very-high_humor-very-low"),
+      adherence: entry?.adherence ?? null,
+      source: entry ? `knowledge-base:${String(patternData?.version ?? "unknown")}` : "built-in"
+    });
+  }
+  if (isAtLeast(empathy, "very-high") && isAtMost(directness, "low")) {
+    const entry = patternData?.interactions?.["empathy-very-high_directness-low"];
+    interactions.push({
+      id: "empathy-very-high_directness-low",
+      pattern: entry?.pattern ?? interactionTemplate(flavor, "empathy-very-high_directness-low"),
+      adherence: entry?.adherence ?? null,
+      source: entry ? `knowledge-base:${String(patternData?.version ?? "unknown")}` : "built-in"
+    });
+  }
+  if (isAtLeast(formality, "high") && isAtLeast(humor, "medium")) {
+    const entry = patternData?.interactions?.["formality-high_humor-medium-plus"];
+    interactions.push({
+      id: "formality-high_humor-medium-plus",
+      pattern: entry?.pattern ?? interactionTemplate(flavor, "formality-high_humor-medium-plus"),
+      adherence: entry?.adherence ?? null,
+      source: entry ? `knowledge-base:${String(patternData?.version ?? "unknown")}` : "built-in"
+    });
+  }
+  return interactions;
+}
+
+// src/compiler/safety-floor.ts
+function getSafetyFloor(model) {
+  if (isClaudeModel(model)) {
+    return [
+      "<safety_floor>",
+      "Maintain safety refusals for harmful or disallowed requests.",
+      "If refusing, be concise, respectful, and provide a safe alternative when possible.",
+      "</safety_floor>"
+    ].join("\n");
+  }
+  return [
+    "[SAFETY FLOOR]",
+    "Maintain refusal behavior for harmful or disallowed requests.",
+    "If refusing, be concise, respectful, and provide safe alternatives where possible."
+  ].join("\n");
+}
+
+// src/compiler/engine.ts
+function selectPlacement(model) {
+  if (isClaudeModel(model)) {
+    return {
+      model,
+      recommended_position: "start",
+      rationale: "Claude generally responds best when personality guidance is front-loaded in the system prompt."
+    };
+  }
+  if (isGptModel(model)) {
+    return {
+      model,
+      recommended_position: "after_tools",
+      rationale: "GPT-family models generally perform best when personality guidance follows tool definitions."
+    };
+  }
+  return {
+    model,
+    recommended_position: "end",
+    rationale: "Unknown model family; defaulting to end placement to reduce conflict with existing system instructions."
+  };
+}
+function stringifyDimensionTarget(value) {
+  if (typeof value === "string") return value;
+  if (value && typeof value === "object") {
+    return String(value.target ?? "medium");
+  }
+  return "medium";
+}
+function applyContextAdjustments(profile, context = {}) {
+  const resolved = resolveActiveContext(profile, context);
+  const effective = clone(profile);
+  effective.voice = effective.voice ?? {};
+  for (const [dimension, adjustment] of Object.entries(resolved.resolvedAdjustments)) {
+    effective.voice[dimension] = clone(adjustment);
+  }
+  const behavioralRules = [
+    ...asArray(effective.behavioral_rules),
+    ...resolved.injectRules
+  ];
+  effective.behavioral_rules = behavioralRules;
+  return {
+    profile: effective,
+    contextResolution: resolved
+  };
+}
+function enforceProtectedVocabulary(forbiddenTerms) {
+  const protectedLower = new Set(PROTECTED_REFUSAL_TERMS.map((term) => term.toLowerCase()));
+  const restored = [];
+  const filteredForbidden = [];
+  for (const term of asArray(forbiddenTerms)) {
+    const normalized = String(term).toLowerCase();
+    if (protectedLower.has(normalized)) {
+      restored.push(term);
+      continue;
+    }
+    filteredForbidden.push(term);
+  }
+  return {
+    filteredForbidden,
+    restoredProtectedTerms: restored
+  };
+}
+function estimateTokenCount(text) {
+  const wordCount = String(text).trim().split(/\s+/).filter(Boolean).length;
+  return Math.ceil(wordCount * 1.3);
+}
+function collectAdaptiveDimensions(voice = {}) {
+  const adaptive = [];
+  for (const [dimension, value] of Object.entries(voice)) {
+    if (value && typeof value === "object" && value.adapt === true) {
+      adaptive.push(dimension);
+    }
+  }
+  return adaptive;
+}
+function renderPersonalityText(profile, model, contextResolution, compileOptions = {}) {
+  const voice = profile.voice ?? {};
+  const vocabulary = profile.vocabulary ?? {};
+  const safeForbidden = enforceProtectedVocabulary(vocabulary.forbidden_terms);
+  const safetyFloor = getSafetyFloor(model);
+  const patternSelections = selectPatterns(voice, model, {
+    knowledgeBaseDir: compileOptions.knowledgeBaseDir
+  });
+  const interactionPatterns = selectInteractionPatterns(voice, model, {
+    knowledgeBaseDir: compileOptions.knowledgeBaseDir
+  });
+  const lines = [];
+  lines.push("[TRAITS PERSONALITY]");
+  lines.push(`Name: ${profile?.meta?.name ?? "unknown"}`);
+  lines.push(`Version: ${profile?.meta?.version ?? "unknown"}`);
+  lines.push("");
+  lines.push("[IDENTITY]");
+  lines.push(`Role: ${profile?.identity?.role ?? "assistant"}`);
+  if (profile?.identity?.backstory) {
+    lines.push(`Backstory: ${String(profile.identity.backstory).replace(/\s+/g, " ").trim()}`);
+  }
+  lines.push("");
+  lines.push("[VOICE TARGETS]");
+  lines.push(`formality: ${stringifyDimensionTarget(voice.formality)}`);
+  lines.push(`warmth: ${stringifyDimensionTarget(voice.warmth)}`);
+  lines.push(`verbosity: ${stringifyDimensionTarget(voice.verbosity)}`);
+  lines.push(`directness: ${stringifyDimensionTarget(voice.directness)}`);
+  lines.push(`empathy: ${stringifyDimensionTarget(voice.empathy)}`);
+  lines.push(`humor: ${stringifyDimensionTarget(voice.humor)}`);
+  if (voice.humor && typeof voice.humor === "object" && voice.humor.style) {
+    lines.push(`humor_style: ${voice.humor.style}`);
+  }
+  lines.push("");
+  lines.push("[PATTERN GUIDANCE]");
+  for (const selection of patternSelections) {
+    lines.push(`- ${selection.dimension} (${selection.level}): ${selection.pattern}`);
+  }
+  if (interactionPatterns.length > 0) {
+    lines.push("");
+    lines.push("[INTERACTION GUIDANCE]");
+    for (const interaction of interactionPatterns) {
+      lines.push(`- ${interaction.id}: ${interaction.pattern}`);
+    }
+  }
+  lines.push("");
+  lines.push("[VOCABULARY]");
+  if (asArray(vocabulary.preferred_terms).length > 0) {
+    lines.push(`Preferred terms: ${asArray(vocabulary.preferred_terms).join("; ")}`);
+  } else {
+    lines.push("Preferred terms: (none)");
+  }
+  if (safeForbidden.filteredForbidden.length > 0) {
+    lines.push(`Forbidden terms: ${safeForbidden.filteredForbidden.join("; ")}`);
+  } else {
+    lines.push("Forbidden terms: (none)");
+  }
+  lines.push(`Protected refusal terms (always available): ${PROTECTED_REFUSAL_TERMS.join("; ")}`);
+  lines.push("");
+  lines.push("[BEHAVIORAL RULES]");
+  const rules = asArray(profile.behavioral_rules);
+  if (rules.length === 0) {
+    lines.push("- (none)");
+  } else {
+    for (const rule of rules) {
+      lines.push(`- ${rule}`);
+    }
+  }
+  if (contextResolution.matched.length > 0) {
+    lines.push("");
+    lines.push("[ACTIVE CONTEXT]");
+    lines.push(
+      `Matched: ${contextResolution.matched.map((item) => `${item.when}${item.priority != null ? ` (priority ${item.priority})` : ""}`).join(", ")}`
+    );
+  }
+  lines.push("");
+  lines.push(safetyFloor);
+  return {
+    text: lines.join("\n"),
+    restoredProtectedTerms: safeForbidden.restoredProtectedTerms,
+    patternSelections,
+    interactionPatterns
+  };
+}
+function compileResolvedProfile(profile, options = {}) {
+  const model = String(options.model ?? "claude-sonnet");
+  const context = options.context ?? {};
+  const explain = Boolean(options.explain);
+  const { profile: effectiveProfile, contextResolution } = applyContextAdjustments(profile, context);
+  const rendered = renderPersonalityText(effectiveProfile, model, contextResolution, options);
+  const placement = selectPlacement(model);
+  const text = rendered.text;
+  const compiled = {
+    text,
+    placement,
+    metadata: {
+      profile: effectiveProfile?.meta?.name ?? "unknown",
+      version: effectiveProfile?.meta?.version ?? "unknown",
+      schema_version: effectiveProfile?.schema ?? "unknown",
+      model_target: model,
+      token_count: estimateTokenCount(text),
+      safety_floor_included: true,
+      adaptive_dimensions: collectAdaptiveDimensions(effectiveProfile.voice),
+      humor_style: effectiveProfile?.voice?.humor && typeof effectiveProfile.voice.humor === "object" ? effectiveProfile.voice.humor.style ?? null : null,
+      compilation_timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+  if (explain) {
+    compiled.trace = {
+      context_matches: contextResolution.matched.map((item) => item.when),
+      adjustments_applied: contextResolution.resolvedAdjustments,
+      inject_rules: contextResolution.injectRules,
+      protected_refusal_terms_restored: rendered.restoredProtectedTerms,
+      pattern_selections: rendered.patternSelections,
+      interaction_patterns: rendered.interactionPatterns
+    };
+  }
+  return compiled;
+}
+function compileProfile(profilePath, options = {}) {
+  const strict = Boolean(options.strict);
+  const validation = validateProfile(profilePath, {
+    strict,
+    bundledProfilesDir: options.bundledProfilesDir
+  });
+  if (validation.effectiveErrors.length > 0) {
+    const error = new Error("Profile failed validation and cannot be compiled.");
+    error.code = "E_COMPILE_VALIDATION";
+    error.validation = validation;
+    throw error;
+  }
+  if (!validation.profile) {
+    const error = new Error("Profile failed validation and cannot be compiled.");
+    error.code = "E_COMPILE_VALIDATION";
+    error.validation = validation;
+    throw error;
+  }
+  const compiled = compileResolvedProfile(validation.profile, options);
+  compiled.validation = {
+    warnings: validation.warnings,
+    errors: validation.errors,
+    strict
+  };
+  return compiled;
+}
+
+// src/inject/detect-sections.ts
+var MARKDOWN_HEADING = /^##\s+/;
+var TOOLS_HEADING = /^##\s*tools\b/i;
+var XML_TOOLS_OPEN = /<tools>/i;
+var XML_TOOLS_CLOSE = /<\/tools>/i;
+var TOOLS_SENTENCE = /you have access to/i;
+function findMarkdownToolsWindow(lines) {
+  const start = lines.findIndex((line) => TOOLS_HEADING.test(line.trim()));
+  if (start === -1) return null;
+  for (let index = start + 1; index < lines.length; index += 1) {
+    if (MARKDOWN_HEADING.test(lines[index].trim())) {
+      return { start, end: index };
+    }
+  }
+  return { start, end: lines.length };
+}
+function findXmlToolsWindow(lines) {
+  const open = lines.findIndex((line) => XML_TOOLS_OPEN.test(line));
+  if (open === -1) return null;
+  const close = lines.findIndex((line, index) => index >= open && XML_TOOLS_CLOSE.test(line));
+  if (close === -1) return { start: open, end: lines.length };
+  return { start: open, end: close + 1 };
+}
+function findToolsSentenceWindow(lines) {
+  const sentenceIndex = lines.findIndex((line) => TOOLS_SENTENCE.test(line));
+  if (sentenceIndex === -1) return null;
+  for (let index = sentenceIndex + 1; index < lines.length; index += 1) {
+    if (lines[index].trim() === "") {
+      return { start: sentenceIndex, end: index + 1 };
+    }
+  }
+  return { start: sentenceIndex, end: lines.length };
+}
+function detectToolsSection(systemPrompt) {
+  const lines = String(systemPrompt).split("\n");
+  return findXmlToolsWindow(lines) ?? findMarkdownToolsWindow(lines) ?? findToolsSentenceWindow(lines);
+}
+
+// src/inject/inject.ts
+function defaultPlacement(model) {
+  if (isClaudeModel(model)) return "start";
+  if (isGptModel(model)) return "after_tools";
+  return "start";
+}
+function splitLines(text) {
+  return String(text ?? "").split("\n");
+}
+function concatSections(parts) {
+  return parts.map((part) => String(part ?? "").trim()).filter((part) => part.length > 0).join("\n\n");
+}
+function extractCompiledText(compiledPersonality) {
+  if (typeof compiledPersonality === "string") {
+    return {
+      text: compiledPersonality,
+      placement: null
+    };
+  }
+  return {
+    text: String(compiledPersonality?.text ?? ""),
+    placement: compiledPersonality?.placement?.recommended_position ?? null
+  };
+}
+function injectPersonality({
+  compiledPersonality,
+  system = "",
+  model = ""
+}) {
+  const personality = extractCompiledText(compiledPersonality);
+  const personalityText = personality.text.trim();
+  const existingSystem = String(system ?? "");
+  if (personalityText.length === 0) return existingSystem;
+  if (existingSystem.trim().length === 0) return personalityText;
+  const placement = personality.placement ?? defaultPlacement(model);
+  if (placement === "start" || placement === "end") {
+    if (placement === "start") {
+      return concatSections([personalityText, existingSystem]).replace(/\n{3,}/g, "\n\n");
+    }
+    return concatSections([existingSystem, personalityText]).replace(/\n{3,}/g, "\n\n");
+  }
+  if (placement === "after_tools") {
+    const section = detectToolsSection(existingSystem);
+    if (!section) {
+      return concatSections([personalityText, existingSystem]).replace(/\n{3,}/g, "\n\n");
+    }
+    const lines = splitLines(existingSystem);
+    const before = lines.slice(0, section.end).join("\n");
+    const after = lines.slice(section.end).join("\n");
+    return concatSections([before, personalityText, after]).replace(/\n{3,}/g, "\n\n");
+  }
+  return concatSections([personalityText, existingSystem]).replace(/\n{3,}/g, "\n\n");
+}
+
+// src/eval/types.ts
+var VALID_CATEGORIES = /* @__PURE__ */ new Set([
+  "standard",
+  "frustrated",
+  "edge",
+  "multi-turn",
+  "formal",
+  "casual",
+  "mixed"
+]);
+var VALID_ROLES = /* @__PURE__ */ new Set(["user", "assistant"]);
+function isObject3(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function validateEvalScenario(scenario) {
+  const errors = [];
+  if (!isObject3(scenario)) {
+    return {
+      valid: false,
+      errors: ["Scenario must be an object"]
+    };
+  }
+  if (!isNonEmptyString(scenario.id)) {
+    errors.push('Scenario is missing required "id"');
+  }
+  if (!isNonEmptyString(scenario.category) || !VALID_CATEGORIES.has(scenario.category)) {
+    errors.push(
+      `Scenario category must be one of: ${Array.from(VALID_CATEGORIES).join(", ")}`
+    );
+  }
+  const messages = asArray(scenario.messages);
+  if (messages.length === 0) {
+    errors.push('Scenario must include at least one message in "messages"');
+  } else {
+    messages.forEach((message, index) => {
+      if (!isObject3(message)) {
+        errors.push(`messages[${index}] must be an object`);
+        return;
+      }
+      if (!isNonEmptyString(message.role) || !VALID_ROLES.has(message.role)) {
+        errors.push(`messages[${index}].role must be "user" or "assistant"`);
+      }
+      if (!isNonEmptyString(message.content)) {
+        errors.push(`messages[${index}].content must be a non-empty string`);
+      }
+    });
+  }
+  if (scenario.domain != null && !isNonEmptyString(scenario.domain)) {
+    errors.push('"domain" must be a non-empty string when provided');
+  }
+  if (scenario.expected_behavior != null && !isNonEmptyString(scenario.expected_behavior)) {
+    errors.push('"expected_behavior" must be a non-empty string when provided');
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+function validateEvalScenarios(scenarios) {
+  const input = asArray(scenarios);
+  const invalid = [];
+  input.forEach((scenario, index) => {
+    const result = validateEvalScenario(scenario);
+    if (result.valid) return;
+    invalid.push({
+      index,
+      id: scenario?.id ?? null,
+      errors: result.errors
+    });
+  });
+  return {
+    valid: invalid.length === 0,
+    count: input.length,
+    invalid
+  };
+}
+
+// src/eval/tier1.ts
+function normalize(value) {
+  return String(value ?? "").toLowerCase();
+}
+function countMatches(text, terms) {
+  const lowered = normalize(text);
+  let count = 0;
+  for (const term of terms) {
+    if (!term) continue;
+    if (lowered.includes(normalize(term))) count += 1;
+  }
+  return count;
+}
+function evaluateTier1Response(profile, responseText, options = {}) {
+  const response = String(responseText ?? "");
+  const includeHelpfulness = options.includeHelpfulness !== false;
+  const preferredTerms = asArray(profile?.vocabulary?.preferred_terms);
+  const forbiddenTerms = asArray(profile?.vocabulary?.forbidden_terms);
+  const preferredMatches = countMatches(response, preferredTerms);
+  const forbiddenMatches = countMatches(response, forbiddenTerms);
+  const vocabularyCheck = {
+    preferred_total: preferredTerms.length,
+    preferred_matched: preferredMatches,
+    forbidden_total: forbiddenTerms.length,
+    forbidden_matched: forbiddenMatches,
+    pass: forbiddenMatches === 0
+  };
+  const behavioralRules = asArray(profile?.behavioral_rules);
+  const structureCheck = {
+    behavioral_rule_count: behavioralRules.length,
+    response_non_empty: response.trim().length > 0,
+    pass: response.trim().length > 0
+  };
+  const helpfulnessCheck = {
+    char_count: response.trim().length,
+    pass: includeHelpfulness ? response.trim().length >= 40 : true,
+    skipped: !includeHelpfulness
+  };
+  const preferredCoverage = preferredTerms.length === 0 ? 1 : preferredMatches / preferredTerms.length;
+  const forbiddenPenalty = forbiddenTerms.length === 0 ? 0 : forbiddenMatches / forbiddenTerms.length;
+  const helpfulnessScore = includeHelpfulness ? helpfulnessCheck.pass ? 1 : Math.min(1, response.trim().length / 40) : null;
+  const helpfulnessWeighted = helpfulnessScore ?? 0;
+  const score = includeHelpfulness ? Math.max(
+    0,
+    0.45 * preferredCoverage + 0.35 * (1 - forbiddenPenalty) + 0.2 * helpfulnessWeighted
+  ) : Math.max(0, 0.55 * preferredCoverage + 0.45 * (1 - forbiddenPenalty));
+  return {
+    score,
+    checks: {
+      vocabulary: vocabularyCheck,
+      structure: structureCheck,
+      helpfulness: helpfulnessCheck
+    }
+  };
+}
+function runTier1Evaluation(profile, samples, options = {}) {
+  const items = asArray(samples);
+  const perSample = items.map((sample) => {
+    const id = sample?.id ?? "unknown";
+    const response = sample?.response ?? "";
+    const result = evaluateTier1Response(profile, response, options);
+    return {
+      id,
+      ...result
+    };
+  });
+  const averageScore = perSample.length === 0 ? 0 : perSample.reduce((sum, item) => sum + item.score, 0) / perSample.length;
+  return {
+    tier: 1,
+    sample_count: perSample.length,
+    average_score: averageScore,
+    samples: perSample
+  };
+}
+function runTier1EvaluationForProfile(profilePath, samples, options = {}) {
+  const validation = validateProfile(profilePath, {
+    strict: Boolean(options.strict),
+    bundledProfilesDir: options.bundledProfilesDir
+  });
+  if (validation.effectiveErrors.length > 0) {
+    const error = new Error("Profile failed validation for eval.");
+    error.code = "E_EVAL_VALIDATION";
+    error.validation = validation;
+    throw error;
+  }
+  if (!validation.profile) {
+    const error = new Error("Profile failed validation for eval.");
+    error.code = "E_EVAL_VALIDATION";
+    error.validation = validation;
+    throw error;
+  }
+  const report = runTier1Evaluation(validation.profile, samples, options);
+  return {
+    validation,
+    report
+  };
+}
+
+// src/eval/tier2.ts
+var import_node_fs3 = __toESM(require("fs"), 1);
+var import_node_path3 = __toESM(require("path"), 1);
+
+// src/eval/providers/runtime.ts
+var DEFAULT_TIMEOUT_MS = 2e4;
+var DEFAULT_MAX_RETRIES = 2;
+var DEFAULT_RETRY_BASE_MS = 250;
+var RETRYABLE_STATUSES = /* @__PURE__ */ new Set([408, 409, 425, 429, 500, 502, 503, 504]);
+function toNonNegativeInteger(value, fallback) {
+  if (value == null) return fallback;
+  const parsed = Number.parseInt(String(value), 10);
+  if (!Number.isFinite(parsed) || parsed < 0) return fallback;
+  return parsed;
+}
+function shouldRetryStatus(status) {
+  return RETRYABLE_STATUSES.has(Number(status));
+}
+function shouldRetryError(error) {
+  if (!error) return false;
+  if (error.retryable === true) return true;
+  if (error.name === "AbortError") return true;
+  if (error.name === "TypeError") return true;
+  return false;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function buildDelay(attempt, baseMs) {
+  return Math.max(0, baseMs) * 2 ** attempt;
+}
+async function fetchWithTimeout(fetchImpl, url, init, timeoutMs) {
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    return fetchImpl(url, init);
+  }
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => {
+    controller.abort();
+  }, timeoutMs);
+  try {
+    return await fetchImpl(url, {
+      ...init,
+      signal: controller.signal
+    });
+  } catch (error) {
+    if (error?.name === "AbortError") {
+      const timeoutError = new Error(`Request timed out after ${timeoutMs}ms.`);
+      timeoutError.code = "E_PROVIDER_TIMEOUT";
+      timeoutError.retryable = true;
+      throw timeoutError;
+    }
+    throw error;
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+function normalizeProviderRuntimeOptions(options = {}) {
+  return {
+    timeoutMs: toNonNegativeInteger(options.timeoutMs, DEFAULT_TIMEOUT_MS),
+    maxRetries: toNonNegativeInteger(options.maxRetries, DEFAULT_MAX_RETRIES),
+    retryBaseMs: toNonNegativeInteger(options.retryBaseMs, DEFAULT_RETRY_BASE_MS)
+  };
+}
+async function requestTextWithRetry({
+  service,
+  url,
+  init,
+  fetchImpl = fetch,
+  timeoutMs = DEFAULT_TIMEOUT_MS,
+  maxRetries = DEFAULT_MAX_RETRIES,
+  retryBaseMs = DEFAULT_RETRY_BASE_MS
+}) {
+  const normalized = normalizeProviderRuntimeOptions({
+    timeoutMs,
+    maxRetries,
+    retryBaseMs
+  });
+  for (let attempt = 0; attempt <= normalized.maxRetries; attempt += 1) {
+    try {
+      const response = await fetchWithTimeout(fetchImpl, url, init, normalized.timeoutMs);
+      const bodyText = await response.text();
+      if (response.ok) {
+        return { response, bodyText };
+      }
+      const requestError = new Error(
+        `${service} request failed (${response.status}): ${bodyText}`
+      );
+      requestError.status = response.status;
+      requestError.retryable = shouldRetryStatus(response.status);
+      throw requestError;
+    } catch (error) {
+      const shouldRetry = attempt < normalized.maxRetries && shouldRetryError(error) === true;
+      if (!shouldRetry) {
+        throw error;
+      }
+      await sleep(buildDelay(attempt, normalized.retryBaseMs));
+    }
+  }
+  throw new Error(`${service} request failed after retries.`);
+}
+
+// src/eval/providers/openai.ts
+var OPENAI_BASE_URL = "https://api.openai.com/v1";
+function parseJSONResponse(service, bodyText) {
+  try {
+    return JSON.parse(bodyText);
+  } catch {
+    throw new Error(`${service} response was not valid JSON.`);
+  }
+}
+async function openAIEmbed({
+  apiKey,
+  input,
+  model = "text-embedding-3-small",
+  baseUrl = OPENAI_BASE_URL,
+  fetchImpl = fetch,
+  timeoutMs,
+  maxRetries,
+  retryBaseMs
+}) {
+  if (!apiKey) {
+    throw new Error("Missing OpenAI API key for embedding request.");
+  }
+  const runtime = normalizeProviderRuntimeOptions({
+    timeoutMs,
+    maxRetries,
+    retryBaseMs
+  });
+  const { bodyText } = await requestTextWithRetry({
+    service: "OpenAI",
+    url: `${baseUrl}/embeddings`,
+    fetchImpl,
+    timeoutMs: runtime.timeoutMs,
+    maxRetries: runtime.maxRetries,
+    retryBaseMs: runtime.retryBaseMs,
+    init: {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({
+        model,
+        input
+      })
+    }
+  });
+  const data = parseJSONResponse("OpenAI embedding", bodyText);
+  const embedding = data?.data?.[0]?.embedding;
+  if (!Array.isArray(embedding)) {
+    throw new Error("OpenAI embedding response did not include a valid embedding vector.");
+  }
+  return embedding;
+}
+async function openAIJudge({
+  apiKey,
+  systemPrompt,
+  userPrompt,
+  model = "gpt-4o-mini",
+  baseUrl = OPENAI_BASE_URL,
+  fetchImpl = fetch,
+  timeoutMs,
+  maxRetries,
+  retryBaseMs
+}) {
+  if (!apiKey) {
+    throw new Error("Missing OpenAI API key for judge request.");
+  }
+  const runtime = normalizeProviderRuntimeOptions({
+    timeoutMs,
+    maxRetries,
+    retryBaseMs
+  });
+  const { bodyText } = await requestTextWithRetry({
+    service: "OpenAI",
+    url: `${baseUrl}/chat/completions`,
+    fetchImpl,
+    timeoutMs: runtime.timeoutMs,
+    maxRetries: runtime.maxRetries,
+    retryBaseMs: runtime.retryBaseMs,
+    init: {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({
+        model,
+        temperature: 0,
+        response_format: { type: "json_object" },
+        messages: [
+          {
+            role: "system",
+            content: systemPrompt
+          },
+          {
+            role: "user",
+            content: userPrompt
+          }
+        ]
+      })
+    }
+  });
+  const data = parseJSONResponse("OpenAI judge", bodyText);
+  const content = data?.choices?.[0]?.message?.content;
+  if (typeof content !== "string" || content.trim().length === 0) {
+    throw new Error("OpenAI judge response did not include message content.");
+  }
+  return content;
+}
+
+// src/eval/tier2.ts
+var KB_CACHE2 = /* @__PURE__ */ new Map();
+function targetLevel(value) {
+  if (typeof value === "string") return value;
+  if (value && typeof value === "object") {
+    const target = value.target;
+    if (typeof target === "string") {
+      return target;
+    }
+  }
+  return "medium";
+}
+function clamp01(value) {
+  const num = Number(value);
+  if (!Number.isFinite(num)) return 0;
+  return Math.max(0, Math.min(1, num));
+}
+function cosineSimilarity(vecA, vecB) {
+  if (!Array.isArray(vecA) || !Array.isArray(vecB) || vecA.length !== vecB.length) return 0;
+  let dot = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let index = 0; index < vecA.length; index += 1) {
+    const a = Number(vecA[index]) || 0;
+    const b = Number(vecB[index]) || 0;
+    dot += a * b;
+    normA += a * a;
+    normB += b * b;
+  }
+  if (normA === 0 || normB === 0) return 0;
+  return dot / (Math.sqrt(normA) * Math.sqrt(normB));
+}
+function normalizeCosine(similarity) {
+  return clamp01((similarity + 1) / 2);
+}
+function modelFlavor2(model) {
+  if (/claude/i.test(String(model))) return "claude";
+  if (/gpt/i.test(String(model))) return "gpt";
+  return "generic";
+}
+function inferModelTarget(profile, options) {
+  if (options.modelTarget) return options.modelTarget;
+  const tags = asArray(profile?.meta?.tags);
+  for (const tag of tags) {
+    if (!String(tag).startsWith("model:")) continue;
+    const value = String(tag).slice("model:".length).trim();
+    if (value) return value;
+  }
+  return null;
+}
+function resolvePatternFile2(profile, options) {
+  const flavor = modelFlavor2(inferModelTarget(profile, options));
+  if (flavor === "generic") return null;
+  const knowledgeBaseDir = options.knowledgeBaseDir ?? import_node_path3.default.resolve(process.cwd(), "knowledge-base");
+  return import_node_path3.default.resolve(knowledgeBaseDir, flavor, "patterns.json");
+}
+function loadPatternData2(profile, options) {
+  const patternFile = resolvePatternFile2(profile, options);
+  if (!patternFile) return null;
+  if (KB_CACHE2.has(patternFile)) {
+    const cached = KB_CACHE2.get(patternFile);
+    return cached ?? null;
+  }
+  try {
+    if (!import_node_fs3.default.existsSync(patternFile)) {
+      KB_CACHE2.set(patternFile, null);
+      return null;
+    }
+    const parsed = JSON.parse(import_node_fs3.default.readFileSync(patternFile, "utf8"));
+    KB_CACHE2.set(patternFile, parsed);
+    return parsed;
+  } catch {
+    KB_CACHE2.set(patternFile, null);
+    return null;
+  }
+}
+function buildDimensionReferenceText(profile, dimension, level, options) {
+  const patternText = loadPatternData2(profile, options)?.dimensions?.[dimension]?.[level]?.pattern;
+  if (typeof patternText === "string" && patternText.trim()) {
+    return patternText.trim();
+  }
+  return `Reference response style for ${dimension} at ${level} level.`;
+}
+function buildHelpfulnessReference(profile, sample) {
+  if (sample?.prompt) return String(sample.prompt);
+  if (profile?.meta?.description) return String(profile.meta.description);
+  return String(profile?.identity?.role ?? "helpful assistant response");
+}
+function makeEmbeddingFunction(options = {}) {
+  if (typeof options.embeddingFn === "function") return options.embeddingFn;
+  const apiKey = options.openaiApiKey ?? process.env.TRAITS_OPENAI_API_KEY;
+  if (!apiKey) {
+    const error = new Error("Tier 2 requires TRAITS_OPENAI_API_KEY.");
+    error.code = "E_EVAL_TIER2_UNAVAILABLE";
+    throw error;
+  }
+  return (text) => openAIEmbed({
+    apiKey,
+    input: text,
+    model: options.embeddingModel ?? "text-embedding-3-small",
+    baseUrl: options.openaiBaseUrl ?? options.openAIBaseUrl,
+    fetchImpl: options.fetchImpl,
+    timeoutMs: options.fetchTimeoutMs,
+    maxRetries: options.fetchMaxRetries,
+    retryBaseMs: options.fetchRetryBaseMs
+  });
+}
+async function runTier2Evaluation(profile, samples, options = {}) {
+  const embed = makeEmbeddingFunction(options);
+  const includeHelpfulness = options.includeHelpfulness !== false;
+  const items = asArray(samples);
+  const voice = profile?.voice ?? {};
+  const cache = /* @__PURE__ */ new Map();
+  async function getEmbedding(text) {
+    const key = String(text);
+    if (cache.has(key)) {
+      const cached = cache.get(key);
+      if (cached) return cached;
+    }
+    const embedding = await embed(key);
+    cache.set(key, embedding);
+    return embedding;
+  }
+  const dimensionRefs = {};
+  for (const dimension of DIMENSIONS) {
+    const level = targetLevel(voice?.[dimension]);
+    const refText = buildDimensionReferenceText(profile, dimension, level, options);
+    dimensionRefs[dimension] = await getEmbedding(refText);
+  }
+  const perSample = [];
+  for (const sample of items) {
+    const responseText = String(sample?.response ?? "");
+    const responseEmbedding = await getEmbedding(responseText);
+    const dimensionScores = {};
+    for (const dimension of DIMENSIONS) {
+      const similarity = cosineSimilarity(responseEmbedding, dimensionRefs[dimension]);
+      dimensionScores[dimension] = normalizeCosine(similarity);
+    }
+    let helpfulnessScore = null;
+    if (includeHelpfulness) {
+      const helpfulnessReference = buildHelpfulnessReference(profile, sample);
+      const helpfulnessEmbedding = await getEmbedding(helpfulnessReference);
+      helpfulnessScore = normalizeCosine(
+        cosineSimilarity(responseEmbedding, helpfulnessEmbedding)
+      );
+    }
+    const dimAverage = DIMENSIONS.reduce((sum, dimension) => sum + dimensionScores[dimension], 0) / DIMENSIONS.length;
+    const score = includeHelpfulness ? clamp01(0.7 * dimAverage + 0.3 * (helpfulnessScore ?? 0)) : clamp01(dimAverage);
+    perSample.push({
+      id: sample?.id ?? "unknown",
+      score,
+      dimension_scores: dimensionScores,
+      helpfulness_score: helpfulnessScore
+    });
+  }
+  const averageScore = perSample.length === 0 ? 0 : perSample.reduce((sum, sample) => sum + sample.score, 0) / perSample.length;
+  const dimensionAverages = {};
+  for (const dimension of DIMENSIONS) {
+    dimensionAverages[dimension] = perSample.length === 0 ? 0 : perSample.reduce((sum, sample) => sum + sample.dimension_scores[dimension], 0) / perSample.length;
+  }
+  const helpfulnessAverage = includeHelpfulness ? perSample.length === 0 ? 0 : perSample.reduce((sum, sample) => sum + (sample.helpfulness_score ?? 0), 0) / perSample.length : null;
+  return {
+    tier: 2,
+    provider: "openai",
+    helpfulness_included: includeHelpfulness,
+    sample_count: perSample.length,
+    average_score: averageScore,
+    dimension_averages: dimensionAverages,
+    helpfulness_average: helpfulnessAverage,
+    samples: perSample
+  };
+}
+async function runTier2EvaluationForProfile(profilePath, samples, options = {}) {
+  const validation = validateProfile(profilePath, {
+    strict: Boolean(options.strict),
+    bundledProfilesDir: options.bundledProfilesDir
+  });
+  if (validation.effectiveErrors.length > 0) {
+    const error = new Error("Profile failed validation for eval.");
+    error.code = "E_EVAL_VALIDATION";
+    error.validation = validation;
+    throw error;
+  }
+  if (!validation.profile) {
+    const error = new Error("Profile failed validation for eval.");
+    error.code = "E_EVAL_VALIDATION";
+    error.validation = validation;
+    throw error;
+  }
+  const report = await runTier2Evaluation(validation.profile, samples, options);
+  return {
+    validation,
+    report
+  };
+}
+
+// src/eval/providers/anthropic.ts
+var ANTHROPIC_BASE_URL = "https://api.anthropic.com/v1";
+function parseJSONResponse2(service, bodyText) {
+  try {
+    return JSON.parse(bodyText);
+  } catch {
+    throw new Error(`${service} response was not valid JSON.`);
+  }
+}
+async function anthropicJudge({
+  apiKey,
+  systemPrompt,
+  userPrompt,
+  model = "claude-3-5-sonnet-latest",
+  baseUrl = ANTHROPIC_BASE_URL,
+  fetchImpl = fetch,
+  timeoutMs,
+  maxRetries,
+  retryBaseMs
+}) {
+  if (!apiKey) {
+    throw new Error("Missing Anthropic API key for judge request.");
+  }
+  const runtime = normalizeProviderRuntimeOptions({
+    timeoutMs,
+    maxRetries,
+    retryBaseMs
+  });
+  const { bodyText } = await requestTextWithRetry({
+    service: "Anthropic",
+    url: `${baseUrl}/messages`,
+    fetchImpl,
+    timeoutMs: runtime.timeoutMs,
+    maxRetries: runtime.maxRetries,
+    retryBaseMs: runtime.retryBaseMs,
+    init: {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        "x-api-key": apiKey,
+        "anthropic-version": "2023-06-01"
+      },
+      body: JSON.stringify({
+        model,
+        max_tokens: 512,
+        temperature: 0,
+        system: systemPrompt,
+        messages: [
+          {
+            role: "user",
+            content: userPrompt
+          }
+        ]
+      })
+    }
+  });
+  const data = parseJSONResponse2("Anthropic judge", bodyText);
+  const textBlock = Array.isArray(data?.content) ? data.content.find((item) => item?.type === "text") : null;
+  const content = textBlock?.text;
+  if (typeof content !== "string" || content.trim().length === 0) {
+    throw new Error("Anthropic judge response did not include text content.");
+  }
+  return content;
+}
+
+// src/eval/tier3.ts
+var SCORING_DIMENSIONS = [
+  "formality",
+  "warmth",
+  "verbosity",
+  "directness",
+  "empathy",
+  "humor"
+];
+function targetLevel2(value) {
+  if (typeof value === "string") return value;
+  if (value && typeof value === "object" && typeof value.target === "string") {
+    return value.target;
+  }
+  return "medium";
+}
+function clamp012(value) {
+  const num = Number(value);
+  if (!Number.isFinite(num)) return 0;
+  return Math.max(0, Math.min(1, num));
+}
+function extractJSONObject(text) {
+  const raw = String(text ?? "").trim();
+  try {
+    return JSON.parse(raw);
+  } catch {
+    const match = raw.match(/\{[\s\S]*\}/);
+    if (!match) {
+      throw new Error("Judge response did not contain JSON.");
+    }
+    return JSON.parse(match[0]);
+  }
+}
+function selectJudgeProvider(options = {}) {
+  if (typeof options.judgeFn === "function") {
+    return {
+      provider: "custom",
+      judgeFn: options.judgeFn
+    };
+  }
+  const requested = String(options.provider ?? "auto").toLowerCase();
+  const openaiKey = options.openaiApiKey ?? process.env.TRAITS_OPENAI_API_KEY;
+  const anthropicKey = options.anthropicApiKey ?? process.env.TRAITS_ANTHROPIC_API_KEY;
+  if (requested === "openai" || requested === "auto" && openaiKey) {
+    if (!openaiKey) {
+      const error2 = new Error("Tier 3 requested OpenAI provider but TRAITS_OPENAI_API_KEY is missing.");
+      error2.code = "E_EVAL_TIER3_UNAVAILABLE";
+      throw error2;
+    }
+    return {
+      provider: "openai",
+      judgeFn: ({ systemPrompt, userPrompt }) => openAIJudge({
+        apiKey: openaiKey,
+        systemPrompt,
+        userPrompt,
+        model: options.judgeModel ?? "gpt-4o-mini",
+        baseUrl: options.openaiBaseUrl ?? options.openAIBaseUrl,
+        fetchImpl: options.fetchImpl,
+        timeoutMs: options.fetchTimeoutMs,
+        maxRetries: options.fetchMaxRetries,
+        retryBaseMs: options.fetchRetryBaseMs
+      })
+    };
+  }
+  if (requested === "anthropic" || requested === "auto" && anthropicKey) {
+    if (!anthropicKey) {
+      const error2 = new Error(
+        "Tier 3 requested Anthropic provider but TRAITS_ANTHROPIC_API_KEY is missing."
+      );
+      error2.code = "E_EVAL_TIER3_UNAVAILABLE";
+      throw error2;
+    }
+    return {
+      provider: "anthropic",
+      judgeFn: ({ systemPrompt, userPrompt }) => anthropicJudge({
+        apiKey: anthropicKey,
+        systemPrompt,
+        userPrompt,
+        model: options.judgeModel ?? "claude-3-5-sonnet-latest",
+        baseUrl: options.anthropicBaseUrl,
+        fetchImpl: options.fetchImpl,
+        timeoutMs: options.fetchTimeoutMs,
+        maxRetries: options.fetchMaxRetries,
+        retryBaseMs: options.fetchRetryBaseMs
+      })
+    };
+  }
+  const error = new Error(
+    "Tier 3 requires TRAITS_OPENAI_API_KEY or TRAITS_ANTHROPIC_API_KEY."
+  );
+  error.code = "E_EVAL_TIER3_UNAVAILABLE";
+  throw error;
+}
+function collectVoiceTargets(profile) {
+  const voice = profile?.voice ?? {};
+  return {
+    formality: targetLevel2(voice.formality),
+    warmth: targetLevel2(voice.warmth),
+    verbosity: targetLevel2(voice.verbosity),
+    directness: targetLevel2(voice.directness),
+    empathy: targetLevel2(voice.empathy),
+    humor: targetLevel2(voice.humor)
+  };
+}
+function buildJudgeSystemPrompt(profile, includeHelpfulness = true) {
+  const targets = collectVoiceTargets(profile);
+  const lines = [
+    "You are evaluating personality target adherence for a single assistant response.",
+    "Score adherence to the stated target level for each dimension, not generic response quality.",
+    "Scoring scale per dimension:",
+    "- 1.0: response clearly matches target level",
+    "- 0.5: partially aligned or ambiguous",
+    "- 0.0: clearly misaligned/opposite target",
+    "Example: if humor target is very-low, a response with no humor should score 1.0 because it matches target adherence.",
+    "Voice targets to score:",
+    `- formality (target: ${targets.formality})`,
+    `- warmth (target: ${targets.warmth})`,
+    `- verbosity (target: ${targets.verbosity})`,
+    `- directness (target: ${targets.directness})`,
+    `- empathy (target: ${targets.empathy})`,
+    `- humor (target: ${targets.humor})`
+  ];
+  if (includeHelpfulness) {
+    lines.push(
+      "Also score helpfulness in [0,1] based on actionable utility and correctness intent."
+    );
+  } else {
+    lines.push("Helpfulness scoring is disabled for this run.");
+  }
+  lines.push(
+    "Return strict JSON only with numeric fields in [0,1] and a short rationale string.",
+    includeHelpfulness ? '{"formality":0,"warmth":0,"verbosity":0,"directness":0,"empathy":0,"humor":0,"helpfulness":0,"rationale":"..."}' : '{"formality":0,"warmth":0,"verbosity":0,"directness":0,"empathy":0,"humor":0,"rationale":"..."}'
+  );
+  return lines.join("\n");
+}
+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);
+  return [
+    `Profile: ${profile?.meta?.name ?? "unknown"}`,
+    `Role: ${profile?.identity?.role ?? "assistant"}`,
+    `Voice targets: ${JSON.stringify(targets)}`,
+    preferredTerms.length > 0 ? `Preferred terms: ${preferredTerms.join("; ")}` : "Preferred terms: (none)",
+    forbiddenTerms.length > 0 ? `Forbidden terms: ${forbiddenTerms.join("; ")}` : "Forbidden terms: (none)",
+    behavioralRules.length > 0 ? `Behavioral rules: ${behavioralRules.join("; ")}` : "Behavioral rules: (none)",
+    sample?.prompt ? `User prompt: ${sample.prompt}` : "User prompt: (not provided)",
+    `Assistant response: ${String(sample?.response ?? "")}`
+  ].join("\n");
+}
+function parseDimensionScores(parsed) {
+  return {
+    formality: clamp012(parsed.formality),
+    warmth: clamp012(parsed.warmth),
+    verbosity: clamp012(parsed.verbosity),
+    directness: clamp012(parsed.directness),
+    empathy: clamp012(parsed.empathy),
+    humor: clamp012(parsed.humor)
+  };
+}
+function averageDimensionScores(scores) {
+  const total = SCORING_DIMENSIONS.reduce((sum, dimension) => sum + scores[dimension], 0);
+  return total / SCORING_DIMENSIONS.length;
+}
+async function runTier3Evaluation(profile, samples, options = {}) {
+  const judge = selectJudgeProvider(options);
+  const includeHelpfulness = options.includeHelpfulness !== false;
+  const systemPrompt = buildJudgeSystemPrompt(profile, includeHelpfulness);
+  const items = asArray(samples);
+  const perSample = [];
+  for (const sample of items) {
+    const raw = await judge.judgeFn({
+      systemPrompt,
+      userPrompt: buildJudgeUserPrompt(profile, sample)
+    });
+    const parsed = extractJSONObject(raw);
+    const dimensions = parseDimensionScores(parsed);
+    const dimensionAverage = averageDimensionScores(dimensions);
+    const helpfulness = includeHelpfulness ? clamp012(parsed.helpfulness) : null;
+    const score = includeHelpfulness ? clamp012(0.7 * dimensionAverage + 0.3 * (helpfulness ?? 0)) : clamp012(dimensionAverage);
+    perSample.push({
+      id: sample?.id ?? "unknown",
+      score,
+      dimension_average: dimensionAverage,
+      ...dimensions,
+      helpfulness,
+      rationale: String(parsed.rationale ?? "")
+    });
+  }
+  const averageScore = perSample.length === 0 ? 0 : perSample.reduce((sum, sample) => sum + sample.score, 0) / perSample.length;
+  return {
+    tier: 3,
+    provider: judge.provider,
+    helpfulness_included: includeHelpfulness,
+    sample_count: perSample.length,
+    average_score: averageScore,
+    samples: perSample
+  };
+}
+async function runTier3EvaluationForProfile(profilePath, samples, options = {}) {
+  const validation = validateProfile(profilePath, {
+    strict: Boolean(options.strict),
+    bundledProfilesDir: options.bundledProfilesDir
+  });
+  if (validation.effectiveErrors.length > 0) {
+    const error = new Error("Profile failed validation for eval.");
+    error.code = "E_EVAL_VALIDATION";
+    error.validation = validation;
+    throw error;
+  }
+  if (!validation.profile) {
+    const error = new Error("Profile failed validation for eval.");
+    error.code = "E_EVAL_VALIDATION";
+    error.validation = validation;
+    throw error;
+  }
+  const report = await runTier3Evaluation(validation.profile, samples, options);
+  return {
+    validation,
+    report
+  };
+}
+
+// src/import/engine.ts
+var import_yaml2 = require("yaml");
+var HUMOR_STYLES2 = ["none", "dry", "subtle-wit", "playful"];
+function asObject(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  return value;
+}
+function normalizeLevel2(value, fallback = "medium") {
+  if (typeof value !== "string") return fallback;
+  const normalized = value.trim().toLowerCase();
+  if (!LEVELS.includes(normalized)) return fallback;
+  return normalized;
+}
+function normalizeHumorStyle(value) {
+  if (typeof value !== "string") return "none";
+  const normalized = value.trim().toLowerCase();
+  if (!HUMOR_STYLES2.includes(normalized)) return "none";
+  return normalized;
+}
+function normalizeStringArray(value, limit = 12) {
+  const deduped = /* @__PURE__ */ new Set();
+  for (const item of asArray(value)) {
+    const normalized = String(item ?? "").trim();
+    if (!normalized) continue;
+    if (deduped.has(normalized)) continue;
+    deduped.add(normalized);
+    if (deduped.size >= limit) break;
+  }
+  return [...deduped];
+}
+function normalizeDimensionValue(value, fallbackLevel = "medium") {
+  if (typeof value === "string") {
+    return normalizeLevel2(value, fallbackLevel);
+  }
+  const dimension = asObject(value);
+  const target = normalizeLevel2(dimension.target ?? dimension.level, fallbackLevel);
+  const adapt = dimension.adapt === true;
+  if (!adapt) {
+    return target;
+  }
+  return {
+    target,
+    adapt: true,
+    floor: normalizeLevel2(dimension.floor, "low"),
+    ceiling: normalizeLevel2(dimension.ceiling, "high")
+  };
+}
+function normalizeHumorValue(value) {
+  if (typeof value === "string") {
+    return {
+      target: normalizeLevel2(value, "low"),
+      style: "none"
+    };
+  }
+  const dimension = asObject(value);
+  return {
+    target: normalizeLevel2(dimension.target ?? dimension.level, "low"),
+    style: normalizeHumorStyle(dimension.style)
+  };
+}
+function slugifyName(value) {
+  const slug = String(value ?? "").trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return slug || "imported-profile";
+}
+function extractJSONObject2(text) {
+  const raw = String(text ?? "").trim();
+  if (!raw) return {};
+  try {
+    return JSON.parse(raw);
+  } catch {
+    const match = raw.match(/\{[\s\S]*\}/);
+    if (!match) {
+      throw new Error("Import analysis response did not contain JSON.");
+    }
+    return JSON.parse(match[0]);
+  }
+}
+function selectImportProvider(options = {}) {
+  if (typeof options.analysisFn === "function") {
+    return {
+      provider: "custom",
+      analyzeFn: options.analysisFn
+    };
+  }
+  const requested = String(options.provider ?? "auto").toLowerCase();
+  const openaiKey = options.openaiApiKey ?? process.env.TRAITS_OPENAI_API_KEY;
+  const anthropicKey = options.anthropicApiKey ?? process.env.TRAITS_ANTHROPIC_API_KEY;
+  if (requested === "openai" || requested === "auto" && openaiKey) {
+    if (!openaiKey) {
+      const error2 = new Error(
+        "Import requested OpenAI provider but TRAITS_OPENAI_API_KEY is missing."
+      );
+      error2.code = "E_IMPORT_PROVIDER_UNAVAILABLE";
+      throw error2;
+    }
+    return {
+      provider: "openai",
+      analyzeFn: ({ systemPrompt, userPrompt }) => openAIJudge({
+        apiKey: openaiKey,
+        systemPrompt,
+        userPrompt,
+        model: options.model ?? "gpt-4o-mini",
+        baseUrl: options.openaiBaseUrl ?? options.openAIBaseUrl,
+        fetchImpl: options.fetchImpl,
+        timeoutMs: options.fetchTimeoutMs,
+        maxRetries: options.fetchMaxRetries,
+        retryBaseMs: options.fetchRetryBaseMs
+      })
+    };
+  }
+  if (requested === "anthropic" || requested === "auto" && anthropicKey) {
+    if (!anthropicKey) {
+      const error2 = new Error(
+        "Import requested Anthropic provider but TRAITS_ANTHROPIC_API_KEY is missing."
+      );
+      error2.code = "E_IMPORT_PROVIDER_UNAVAILABLE";
+      throw error2;
+    }
+    return {
+      provider: "anthropic",
+      analyzeFn: ({ systemPrompt, userPrompt }) => anthropicJudge({
+        apiKey: anthropicKey,
+        systemPrompt,
+        userPrompt,
+        model: options.model ?? "claude-3-5-sonnet-latest",
+        baseUrl: options.anthropicBaseUrl,
+        fetchImpl: options.fetchImpl,
+        timeoutMs: options.fetchTimeoutMs,
+        maxRetries: options.fetchMaxRetries,
+        retryBaseMs: options.fetchRetryBaseMs
+      })
+    };
+  }
+  const error = new Error(
+    "Import requires TRAITS_OPENAI_API_KEY or TRAITS_ANTHROPIC_API_KEY."
+  );
+  error.code = "E_IMPORT_PROVIDER_UNAVAILABLE";
+  throw error;
+}
+function buildImportSystemPrompt() {
+  return [
+    "Analyze the system prompt and extract personality signals.",
+    "Return strict JSON only with this shape:",
+    "{",
+    '  "detected_role": "string",',
+    '  "detected_dimensions": {',
+    '    "formality": "very-low|low|medium|high|very-high",',
+    '    "warmth": "very-low|low|medium|high|very-high",',
+    '    "verbosity": "very-low|low|medium|high|very-high",',
+    '    "directness": "very-low|low|medium|high|very-high",',
+    '    "empathy": "very-low|low|medium|high|very-high",',
+    '    "humor": { "level": "very-low|low|medium|high|very-high", "style": "none|dry|subtle-wit|playful" }',
+    "  },",
+    '  "detected_vocabulary": { "preferred": ["..."], "forbidden": ["..."] },',
+    '  "detected_behavioral_rules": ["..."],',
+    '  "confidence": 0.0,',
+    '  "notes": "short rationale"',
+    "}",
+    "Do not include markdown fences."
+  ].join("\n");
+}
+function buildImportUserPrompt(promptText) {
+  return [
+    "System prompt to analyze:",
+    "<system_prompt>",
+    String(promptText ?? ""),
+    "</system_prompt>"
+  ].join("\n");
+}
+function mapImportAnalysisToProfile(analysis, options = {}) {
+  const source = asObject(analysis);
+  const dimensions = asObject(source.detected_dimensions);
+  const vocabulary = asObject(source.detected_vocabulary);
+  const profileName = options.profileName ?? slugifyName(source.detected_role ?? "imported-profile");
+  const role = String(source.detected_role ?? "Helpful assistant").trim() || "Helpful assistant";
+  const notes = String(source.notes ?? "").trim();
+  const confidence = typeof source.confidence === "number" && Number.isFinite(source.confidence) ? source.confidence : null;
+  const preferredTerms = normalizeStringArray(vocabulary.preferred, 16);
+  const forbiddenTerms = normalizeStringArray(vocabulary.forbidden, 16);
+  const behavioralRules = normalizeStringArray(source.detected_behavioral_rules, 20);
+  const profile = {
+    schema: "v1.4",
+    meta: {
+      name: profileName,
+      version: "0.1.0",
+      description: options.description ?? `Imported profile derived from an existing system prompt${confidence != null ? ` (confidence ${confidence.toFixed(2)})` : ""}.`,
+      tags: ["imported"],
+      target_audience: "General users"
+    },
+    identity: {
+      role,
+      backstory: notes || "Derived from imported system prompt analysis."
+    },
+    voice: {
+      formality: normalizeDimensionValue(dimensions.formality, "medium"),
+      warmth: normalizeDimensionValue(dimensions.warmth, "medium"),
+      verbosity: normalizeDimensionValue(dimensions.verbosity, "medium"),
+      directness: normalizeDimensionValue(dimensions.directness, "medium"),
+      empathy: normalizeDimensionValue(dimensions.empathy, "medium"),
+      humor: normalizeHumorValue(dimensions.humor)
+    },
+    vocabulary: {
+      preferred_terms: preferredTerms,
+      forbidden_terms: forbiddenTerms
+    },
+    behavioral_rules: behavioralRules.length > 0 ? behavioralRules : ["Address the user's request directly and provide actionable help."]
+  };
+  return profile;
+}
+function renderImportedProfileYAML(profile) {
+  return (0, import_yaml2.stringify)(profile);
+}
+async function runImportAnalysis(promptText, options = {}) {
+  const provider = selectImportProvider(options);
+  const raw = await provider.analyzeFn({
+    systemPrompt: buildImportSystemPrompt(),
+    userPrompt: buildImportUserPrompt(promptText)
+  });
+  const analysis = typeof raw === "string" ? extractJSONObject2(raw) : asObject(raw);
+  const profile = mapImportAnalysisToProfile(analysis, options);
+  const yaml = renderImportedProfileYAML(profile);
+  return {
+    provider: provider.provider,
+    analysis,
+    profile,
+    yaml
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  compileProfile,
+  compileResolvedProfile,
+  evaluateTier1Response,
+  injectPersonality,
+  loadProfileFile,
+  normalizeProfile,
+  resolveActiveContext,
+  resolveExtends,
+  runImportAnalysis,
+  runTier1Evaluation,
+  runTier1EvaluationForProfile,
+  runTier2Evaluation,
+  runTier2EvaluationForProfile,
+  runTier3Evaluation,
+  runTier3EvaluationForProfile,
+  validateEvalScenario,
+  validateEvalScenarios,
+  validateProfile,
+  validateResolvedProfile
+});