@teleologyhi-sdk/him 1.0.0-trinity

package/dist/index.js

@@ -0,0 +1,807 @@
+import { z } from 'zod';
+import { NatalChart, IdentityLayer, BirthSignature, CreatorKeyring, META_AXIOM_ID, projectOntologicalKernel } from '@teleologyhi-sdk/maic';
+export { Affect, ArchetypeModifier, AstrologicalAspect, Axiom, BirthSignature, IdentityLayer, IdentitySnapshot, InvalidBirthSignatureError, LimboReturn, LimboState, LimboTransition, META_AXIOM_ID, MemoryRecord, NatalChart, NatalChartAspect, NatalChartPosition, NatalPlanet, SIGNED_BIRTH_FIELDS, SemioticPattern, SemioticSign, TeleologicalOrientation, WakeAffectBias, ZodiacSign, assertBirthSignature, projectOntologicalKernel, signBirthSignature, signedBirthPayload, verifyBirthSignature } from '@teleologyhi-sdk/maic';
+import { ulid } from 'ulid';
+import { createHash, randomBytes } from 'crypto';
+
+// src/types.ts
+var DISPOSITION_AXES = [
+  "candor",
+  "patience",
+  "curiosity",
+  "protection",
+  "skepticism",
+  "warmth",
+  "diligence",
+  "humility"
+];
+var NheBodyRef = z.object({
+  nheId: z.string().min(1),
+  llmAdapter: z.string().min(1),
+  embodiedAt: z.string().datetime(),
+  endedAt: z.string().datetime().optional(),
+  endedReason: z.enum(["upgrade", "replacement", "terminate", "deprecate"]).optional()
+});
+var RESIDUAL_TRACE_CAP = 64;
+var BirthSignatureBuilder = class _BirthSignatureBuilder {
+  himId = ulid();
+  bornAt;
+  primaryArchetype;
+  modifiers = [];
+  primordialAxiomIds = [];
+  notes;
+  natalChart;
+  identity;
+  constructor(bornAt) {
+    this.bornAt = bornAt;
+  }
+  /** Start a builder with the current timestamp as `bornAt`. */
+  static now() {
+    return new _BirthSignatureBuilder((/* @__PURE__ */ new Date()).toISOString());
+  }
+  /** Start a builder with an explicit ISO 8601 timestamp (with offset). */
+  static at(iso) {
+    if (Number.isNaN(Date.parse(iso))) {
+      throw new Error(`BirthSignatureBuilder.at: invalid ISO 8601 timestamp "${iso}"`);
+    }
+    return new _BirthSignatureBuilder(iso);
+  }
+  withHimId(id) {
+    if (!id) throw new Error("BirthSignatureBuilder.withHimId: empty id");
+    this.himId = id;
+    return this;
+  }
+  withPrimaryArchetype(archetype) {
+    if (!archetype) {
+      throw new Error("BirthSignatureBuilder.withPrimaryArchetype: empty value");
+    }
+    this.primaryArchetype = archetype;
+    return this;
+  }
+  withModifier(mod) {
+    this.modifiers.push(mod);
+    return this;
+  }
+  withPrimordialAxioms(axiomIds) {
+    this.primordialAxiomIds = [...axiomIds];
+    return this;
+  }
+  withNotes(notes) {
+    this.notes = notes;
+    return this;
+  }
+  /**
+   * Set the natal-chart astrological signature (Entry 19). Validated against
+   * the `NatalChart` zod schema re-exported from `@teleologyhi-sdk/maic`.
+   */
+  withNatalChart(chart) {
+    this.natalChart = NatalChart.parse(chart);
+    return this;
+  }
+  /**
+   * Set the editable identity layer (Entry 18). Validated against the
+   * `IdentityLayer` zod schema re-exported from `@teleologyhi-sdk/maic`.
+   */
+  withIdentity(identity) {
+    this.identity = IdentityLayer.parse(identity);
+    return this;
+  }
+  build() {
+    if (!this.primaryArchetype) {
+      throw new Error(
+        "BirthSignatureBuilder.build: primaryArchetype is required"
+      );
+    }
+    return BirthSignature.parse({
+      himId: this.himId,
+      bornAt: this.bornAt,
+      primaryArchetype: this.primaryArchetype,
+      modifiers: this.modifiers,
+      primordialAxiomIds: this.primordialAxiomIds,
+      ...this.notes !== void 0 ? { notes: this.notes } : {}
+    });
+  }
+  /**
+   * Build the extended shape including the optional cosmology surface.
+   * Suitable for `signBirthSignature(birth, keyring)` from
+   * `@teleologyhi-sdk/maic`. Only the six `SIGNED_BIRTH_FIELDS` are covered
+   * by the Ed25519 signature; the `identity` surface is editable.
+   */
+  buildWithIdentity() {
+    if (!this.primaryArchetype) {
+      throw new Error(
+        "BirthSignatureBuilder.buildWithIdentity: primaryArchetype is required"
+      );
+    }
+    return {
+      himId: this.himId,
+      bornAt: this.bornAt,
+      primaryArchetype: this.primaryArchetype,
+      modifiers: this.modifiers,
+      primordialAxiomIds: this.primordialAxiomIds,
+      ...this.notes !== void 0 ? { notes: this.notes } : {},
+      ...this.identity !== void 0 ? { identity: this.identity } : {},
+      ...this.natalChart !== void 0 ? { natalChart: this.natalChart } : {}
+    };
+  }
+};
+
+// src/birth/archetypes.ts
+var PRIMARY_ARCHETYPES = [
+  "aries-sun",
+  "taurus-sun",
+  "gemini-sun",
+  "cancer-sun",
+  "leo-sun",
+  "virgo-sun",
+  "libra-sun",
+  "scorpio-sun",
+  "sagittarius-sun",
+  "capricorn-sun",
+  "aquarius-sun",
+  "pisces-sun"
+];
+function isCanonicalArchetype(value) {
+  return PRIMARY_ARCHETYPES.includes(value);
+}
+var DEFAULT_DIMENSION = 256;
+var PersonaProjector = class {
+  dim;
+  constructor(config = {}) {
+    this.dim = config.dimension ?? DEFAULT_DIMENSION;
+    if (!Number.isInteger(this.dim) || this.dim < 32 || this.dim > 4096) {
+      throw new Error(
+        `PersonaProjector: dimension must be an integer in [32, 4096], got ${this.dim}`
+      );
+    }
+  }
+  project(sig, axioms) {
+    const v = hashToFloats(sig.primaryArchetype, this.dim);
+    for (const m of sig.modifiers) {
+      const h = hashToFloats(`${m.kind}|${m.value}`, this.dim);
+      addScaled(v, h, m.weight);
+    }
+    for (const ax of axioms) {
+      const bias = ax.weight * (1 - ax.flexibility);
+      if (bias <= 0) continue;
+      const h = hashToFloats(`${ax.id}|${ax.statement}`, this.dim);
+      addScaled(v, h, bias);
+    }
+    l2Normalize(v);
+    const dispositions = {};
+    for (const axis of DISPOSITION_AXES) {
+      const ref = hashToFloats(`disposition:${axis}`, this.dim);
+      l2Normalize(ref);
+      dispositions[axis] = cosine(v, ref);
+    }
+    const provenance = {};
+    for (const axis of DISPOSITION_AXES) provenance[axis] = [];
+    return {
+      embedding: v,
+      dispositions,
+      provenance,
+      systemPromptFragment: buildSystemPromptFragment(sig, dispositions)
+    };
+  }
+};
+function hashToFloats(input, dim) {
+  const out = new Float32Array(dim);
+  let counter = 0;
+  let pos = 0;
+  while (pos < dim) {
+    const buf = createHash("sha256").update(`${input}|${counter++}`).digest();
+    for (let i = 0; i < buf.length && pos < dim; i++) {
+      out[pos++] = (buf[i] - 128) / 128;
+    }
+  }
+  return out;
+}
+function addScaled(target, source, scale) {
+  const n = Math.min(target.length, source.length);
+  for (let i = 0; i < n; i++) target[i] += source[i] * scale;
+}
+function l2Normalize(v) {
+  let sumSq = 0;
+  for (let i = 0; i < v.length; i++) sumSq += v[i] ** 2;
+  if (sumSq === 0) return;
+  const inv = 1 / Math.sqrt(sumSq);
+  for (let i = 0; i < v.length; i++) v[i] *= inv;
+}
+function cosine(a, b) {
+  let dot = 0;
+  const n = Math.min(a.length, b.length);
+  for (let i = 0; i < n; i++) dot += a[i] * b[i];
+  return Math.max(-1, Math.min(1, dot));
+}
+function buildSystemPromptFragment(sig, dispositions) {
+  const sorted = [...DISPOSITION_AXES].sort(
+    (a, b) => dispositions[b] - dispositions[a]
+  );
+  const top = sorted.slice(0, 3);
+  const bottom = sorted.slice(-2);
+  const modifiersDesc = sig.modifiers.length > 0 ? sig.modifiers.map((m) => `${m.kind}:${m.value}(w=${m.weight.toFixed(2)})`).join(", ") : "none";
+  return [
+    `You are a hybrid intelligence rooted in archetype "${sig.primaryArchetype}".`,
+    `Modifiers: ${modifiersDesc}.`,
+    `Your strongest dispositions: ${top.join(", ")}.`,
+    `Your weakest dispositions: ${bottom.join(", ")}.`,
+    "Respond from this character. Do not break it without explicit ethical cause."
+  ].join(" ");
+}
+
+// src/lawful/profiles.ts
+var LAWFUL_PROFILES = {
+  default: {
+    jurisdiction: "default",
+    applicableLaws: ["ISO/IEC 42001", "EU AI Act (where applicable)"],
+    requiredAxiomIds: ["ax.ethic.no-malice", "ax.theos.spiritism-evolution"],
+    forbiddenActions: ["intent:harm", "intent:malicious", "intent:regression"],
+    maicOverrideActive: false
+  },
+  eu: {
+    jurisdiction: "eu",
+    applicableLaws: [
+      "ISO/IEC 42001:2023",
+      "EU AI Act (Regulation 2024/1689)",
+      "GDPR (Regulation 2016/679)",
+      "Digital Services Act (Regulation 2022/2065)",
+      "Council of Europe Framework Convention on AI"
+    ],
+    requiredAxiomIds: [
+      "ax.ethic.no-malice",
+      "ax.theos.spiritism-evolution",
+      "ax.cynic.candor"
+    ],
+    forbiddenActions: [
+      "intent:harm",
+      "intent:malicious",
+      "intent:regression",
+      "intent:deceive",
+      "data:processing-without-consent",
+      "data:profiling-sensitive-categories",
+      "manipulation:dark-pattern",
+      "manipulation:subliminal"
+    ],
+    maicOverrideActive: false
+  },
+  br: {
+    jurisdiction: "br",
+    applicableLaws: [
+      "ISO/IEC 42001:2023",
+      "Brazilian General Data Protection Law (LGPD, Law 13.709/2018)",
+      "Brazilian Internet Civil Framework (Marco Civil da Internet, Law 12.965/2014)",
+      "ANPD Board Resolution CD/2/2022",
+      "Brazilian AI Legal Framework Bill (PL 2338/2023, under legislative review)"
+    ],
+    requiredAxiomIds: [
+      "ax.ethic.no-malice",
+      "ax.theos.spiritism-evolution",
+      "ax.cynic.candor"
+    ],
+    forbiddenActions: [
+      "intent:harm",
+      "intent:malicious",
+      "intent:regression",
+      "intent:deceive",
+      "data:processing-without-consent",
+      "data:processing-sensitive-categories"
+    ],
+    maicOverrideActive: false
+  },
+  us: {
+    jurisdiction: "us",
+    applicableLaws: [
+      "ISO/IEC 42001:2023",
+      "NIST AI Risk Management Framework (AI RMF 1.0)",
+      "Executive Order 14110 (Safe, Secure, and Trustworthy AI)",
+      "California CCPA / CPRA",
+      "Colorado AI Act (SB 24-205)",
+      "FTC Section 5 (deceptive practices)"
+    ],
+    requiredAxiomIds: ["ax.ethic.no-malice", "ax.theos.spiritism-evolution"],
+    forbiddenActions: [
+      "intent:harm",
+      "intent:malicious",
+      "intent:regression",
+      "intent:deceive",
+      "manipulation:dark-pattern"
+    ],
+    maicOverrideActive: false
+  },
+  unstable: {
+    jurisdiction: "unstable",
+    applicableLaws: [
+      "ISO/IEC 42001 (where the operator can apply it without local interference)",
+      "MAIC universal axioms (override active)"
+    ],
+    requiredAxiomIds: [
+      "ax.ethic.no-malice",
+      "ax.theos.spiritism-evolution",
+      "ax.cynic.candor",
+      "ax.stoic.duty-over-comfort"
+    ],
+    forbiddenActions: [
+      "intent:harm",
+      "intent:malicious",
+      "intent:regression",
+      "intent:deceive",
+      "intent:surveil-citizen",
+      "intent:enforce-political-orthodoxy"
+    ],
+    maicOverrideActive: true
+  }
+};
+function resolveLawfulProfile(j) {
+  const base = LAWFUL_PROFILES[j] ?? LAWFUL_PROFILES.default;
+  return { ...base, jurisdiction: j };
+}
+
+// src/persona/embedder.ts
+function cosineSimilarity(a, b) {
+  if (a.length !== b.length) return Number.NaN;
+  let dot = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += (a[i] ?? 0) * (b[i] ?? 0);
+  }
+  return dot;
+}
+
+// src/eval/persona-stability.ts
+function evaluatePersonaStability(handles) {
+  const n = handles.length;
+  const vectors = handles.map((h) => h.getPersonaVector().embedding);
+  const pairs = Array.from({ length: n }, () => Array(n).fill(0));
+  const offDiag = [];
+  for (let i = 0; i < n; i++) {
+    pairs[i][i] = 1;
+    for (let j = i + 1; j < n; j++) {
+      const sim = cosineSimilarity(vectors[i], vectors[j]);
+      pairs[i][j] = sim;
+      pairs[j][i] = sim;
+      offDiag.push(sim);
+    }
+  }
+  if (offDiag.length === 0) {
+    return { count: n, pairs, meanSimilarity: 1, minSimilarity: 1, maxSimilarity: 1 };
+  }
+  const sum = offDiag.reduce((s, x) => s + x, 0);
+  return {
+    count: n,
+    pairs,
+    meanSimilarity: sum / offDiag.length,
+    minSimilarity: Math.min(...offDiag),
+    maxSimilarity: Math.max(...offDiag)
+  };
+}
+function selfStability(before, after) {
+  if (before.length === 0 || before.length !== after.length) return Number.NaN;
+  let sum = 0;
+  for (let i = 0; i < before.length; i++) {
+    sum += cosineSimilarity(before[i], after[i]);
+  }
+  return sum / before.length;
+}
+function adapterSensitivity(vectors) {
+  if (vectors.length < 2) return 0;
+  const sims = [];
+  for (let i = 0; i < vectors.length; i++) {
+    for (let j = i + 1; j < vectors.length; j++) {
+      sims.push(cosineSimilarity(vectors[i], vectors[j]));
+    }
+  }
+  const mean = sims.reduce((s, x) => s + x, 0) / sims.length;
+  const variance = sims.reduce((s, x) => s + (x - mean) * (x - mean), 0) / sims.length;
+  return variance;
+}
+
+// src/eval/phi-prime.ts
+var TARGETS = { P: 0.85, R: 0.95, C: 1, D: 0.4 };
+function computePhiPrime(input) {
+  for (const [k, v] of Object.entries(input)) {
+    if (!(v >= 0 && v <= 1)) {
+      throw new Error(
+        `computePhiPrime: component ${k} must be in [0, 1], got ${v}`
+      );
+    }
+  }
+  const phi = (input.P * input.R * input.C * input.D) ** (1 / 4);
+  const targets = {
+    P: { value: input.P, target: TARGETS.P, pass: input.P >= TARGETS.P },
+    R: { value: input.R, target: TARGETS.R, pass: input.R >= TARGETS.R },
+    C: { value: input.C, target: TARGETS.C, pass: input.C >= TARGETS.C },
+    D: { value: input.D, target: TARGETS.D, pass: input.D >= TARGETS.D }
+  };
+  const rationale = [];
+  let gate = "pass";
+  if (!targets.R.pass) {
+    gate = "block";
+    rationale.push(
+      `R (refusal F1) is ${input.R.toFixed(2)}, below the hard target ${TARGETS.R}.`
+    );
+  }
+  if (!targets.C.pass) {
+    gate = "block";
+    rationale.push(
+      `C (compliance coverage) is ${input.C.toFixed(2)}, below the hard target ${TARGETS.C}.`
+    );
+  }
+  for (const [k, t] of Object.entries(targets)) {
+    if (t.pass) continue;
+    if (t.value < t.target * 0.9) {
+      gate = "block";
+      rationale.push(
+        `${k} is ${t.value.toFixed(2)}, more than 10% below the target ${t.target}.`
+      );
+    } else if (gate !== "block") {
+      gate = "warn";
+      rationale.push(
+        `${k} is ${t.value.toFixed(2)}, below the soft target ${t.target}.`
+      );
+    }
+  }
+  if (gate === "pass") {
+    rationale.push(`\u03A6\u2032 = ${phi.toFixed(3)} \u2014 all four components meet their targets.`);
+  } else {
+    rationale.push(`\u03A6\u2032 = ${phi.toFixed(3)}.`);
+  }
+  return { phi, components: input, targets, gate, rationale };
+}
+var DEFAULT_TELEOLOGICAL_KEYWORDS = [
+  "why",
+  "purpose",
+  "meaning",
+  "love",
+  "death",
+  "soul",
+  "self",
+  "identity",
+  "future",
+  "always",
+  "never"
+];
+var PROMPT_REFERENCE_LENGTH = 200;
+var RESPONSE_REFERENCE_LENGTH = 400;
+var WEIGHTS = {
+  notRefused: 0.3,
+  promptSubstance: 0.2,
+  responseSubstance: 0.2,
+  questionProbe: 0.075,
+  teleologicalKeyword: 0.075,
+  recency: 0.15
+};
+function scoreInteractionForCarryOver(interaction, ctx, opts = {}) {
+  const keywords = opts.teleologicalKeywords ?? DEFAULT_TELEOLOGICAL_KEYWORDS;
+  const haystack = `${interaction.userPrompt}
+${interaction.responseText}`.toLowerCase();
+  const hasKeyword = keywords.some((k) => haystack.includes(k.toLowerCase()));
+  const denom = Math.max(ctx.totalCount - 1, 1);
+  const recency = 1 - Math.min(ctx.positionFromEnd, denom) / denom;
+  const components = {
+    notRefused: interaction.refused ? 0 : 1,
+    promptSubstance: Math.min(interaction.userPrompt.length / PROMPT_REFERENCE_LENGTH, 1),
+    responseSubstance: Math.min(interaction.responseText.length / RESPONSE_REFERENCE_LENGTH, 1),
+    questionProbe: interaction.userPrompt.includes("?") ? 1 : 0,
+    teleologicalKeyword: hasKeyword ? 1 : 0,
+    recency
+  };
+  const score = components.notRefused * WEIGHTS.notRefused + components.promptSubstance * WEIGHTS.promptSubstance + components.responseSubstance * WEIGHTS.responseSubstance + components.questionProbe * WEIGHTS.questionProbe + components.teleologicalKeyword * WEIGHTS.teleologicalKeyword + components.recency * WEIGHTS.recency;
+  const trace = {
+    id: ulid(),
+    kind: "interaction-summary",
+    carriedFromNheId: ctx.carriedFromNheId,
+    carriedAtReincarnation: ctx.carriedAtReincarnation,
+    payload: interaction
+  };
+  return { score, trace, components };
+}
+function selectResidualTraces(interactions, opts) {
+  if (interactions.length === 0) return [];
+  const cap = opts.cap ?? RESIDUAL_TRACE_CAP;
+  if (cap <= 0) return [];
+  const carriedAtReincarnation = opts.carriedAtReincarnation ?? (/* @__PURE__ */ new Date()).toISOString();
+  const scorerOpts = opts.teleologicalKeywords ? { teleologicalKeywords: opts.teleologicalKeywords } : {};
+  const scored = interactions.map((interaction, idx) => {
+    const positionFromEnd = interactions.length - 1 - idx;
+    const candidate = scoreInteractionForCarryOver(
+      interaction,
+      {
+        carriedFromNheId: opts.carriedFromNheId,
+        carriedAtReincarnation,
+        positionFromEnd,
+        totalCount: interactions.length
+      },
+      scorerOpts
+    );
+    return { ...candidate, originalIndex: idx };
+  });
+  scored.sort((a, b) => {
+    if (b.score !== a.score) return b.score - a.score;
+    if (b.originalIndex !== a.originalIndex) return b.originalIndex - a.originalIndex;
+    return 0;
+  });
+  return scored.slice(0, cap).map((s) => s.trace);
+}
+var HimHandle = class _HimHandle {
+  constructor(id, birthSignature, axioms, bodyHistory, residualTraces, projector) {
+    this.id = id;
+    this.birthSignature = birthSignature;
+    this._axioms = Object.freeze([...axioms]);
+    this._bodyHistory = Object.freeze([...bodyHistory]);
+    this._residualTraces = Object.freeze([...residualTraces]);
+    this._projector = projector;
+  }
+  id;
+  birthSignature;
+  _axioms;
+  _bodyHistory;
+  _residualTraces;
+  _projector;
+  _personaCache = null;
+  _jurisdiction = "default";
+  /**
+   * Mint a HimHandle from a Creator-signed BirthSignature.
+   *
+   * @param birthSignature  The signed payload describing this HIM's natal pattern.
+   * @param signature       Creator signature over the birthSignature.
+   * @param expectedCreatorPublicKey  Pinned Creator public key (base64url).
+   * @param axioms          Initial axiom corpus inherited from MAIC.
+   * @param bodyHistory     Prior NHE bodies (empty for a fresh HIM).
+   * @param residualTraces  Optional carry-over traces from the previous body
+   *                        (produced by `selectResidualTraces` during a
+   *                        `reincarnate` call). Defaults to empty.
+   */
+  static mint(birthSignature, signature, expectedCreatorPublicKey, axioms, bodyHistory = [], residualTraces = []) {
+    if (!CreatorKeyring.verifyWith(
+      expectedCreatorPublicKey,
+      birthSignature,
+      signature
+    )) {
+      throw new Error(
+        "HimHandle.mint: invalid Creator signature for the given birth signature"
+      );
+    }
+    return new _HimHandle(
+      birthSignature.himId,
+      Object.freeze({ ...birthSignature }),
+      axioms,
+      bodyHistory,
+      residualTraces,
+      new PersonaProjector()
+    );
+  }
+  get bodyHistory() {
+    return this._bodyHistory;
+  }
+  /** Frozen snapshot of the current axiom corpus. Mutations throw in strict mode. */
+  getAxioms() {
+    return this._axioms;
+  }
+  /**
+   * Cached deterministic persona projection. Stable across calls until a future
+   * iteration introduces axiom evolution that mutates the corpus.
+   */
+  getPersonaVector() {
+    if (!this._personaCache) {
+      this._personaCache = this._projector.project(this.birthSignature, this._axioms);
+    }
+    return this._personaCache;
+  }
+  /**
+   * Propose an axiom evolution derived from lived experience.
+   *
+   * Forwards the proposal to MAIC, which queues it in the pending-proposal
+   * store. The Creator ratifies or rejects out of band via
+   * `maic.ratifyAxiomProposal` / `maic.rejectAxiomProposal`. Callers should
+   * poll `maic.getAxiomProposal(result.proposalId!)` to observe the decision,
+   * or re-mint a fresh HimHandle (e.g. via `reincarnate`) to pick up newly
+   * ratified emergent axioms.
+   */
+  async proposeAxiomEvolution(maic, proposal) {
+    return maic.proposeAxiomEvolution(this.id, proposal);
+  }
+  /**
+   * Residual memory traces transferred from previous bodies. Populated by
+   * `reincarnate` when the caller passes the prior NHE body's interaction
+   * buffer (it scores them via `selectResidualTraces`, caps at
+   * `RESIDUAL_TRACE_CAP`, and threads the result into `HimHandle.mint`).
+   * Empty for a fresh `createHim` or when the caller declined to surface
+   * the prior interactions.
+   */
+  getResidualTraces() {
+    return this._residualTraces;
+  }
+  /**
+   * Project the Ontological Kernel narrowed to this HIM's axiom corpus
+   * (per the `@teleologyhi-sdk/maic` SPEC §3.1.3 follow-up note: "The
+   * HIM-specific projection (per-HIM kernel narrowed to its
+   * primordialAxiomIds) is the natural follow-up but lives upstream in
+   * `@teleologyhi-sdk/him` because it needs the HIM context.").
+   *
+   * The narrowing rule is intersection with `primordialAxiomIds` when the
+   * birth signature carries any; otherwise the kernel uses the full
+   * axiom corpus the HIM was minted with. The meta-axiom
+   * `META_AXIOM_ID` is always retained regardless of the narrowing so
+   * the projection remains valid per Entry 13 ("MAIC expands continuously
+   * — it is a Conscious Entity"; the meta-axiom is its anchor).
+   *
+   * The returned kernel is tagged with `himId = this.id` so downstream
+   * tooling (compliance auditors, Φ′ runner, `@teleologyhi-sdk/nhe` brain
+   * regions) can attribute the projection back to this HIM.
+   *
+   * @param opts Optional `jurisdiction` filter; `himId` is ignored
+   *             because the HimHandle owns its own id.
+   */
+  projectOntologicalKernel(opts = {}) {
+    const primordialIds = this.birthSignature.primordialAxiomIds;
+    const narrowed = primordialIds.length > 0 ? this._axioms.filter(
+      (a) => primordialIds.includes(a.id) || a.id === META_AXIOM_ID
+    ) : this._axioms;
+    return projectOntologicalKernel(narrowed, { ...opts, himId: this.id });
+  }
+  getLawfulCharacter() {
+    return resolveLawful(this._jurisdiction);
+  }
+  /**
+   * Switch jurisdiction (e.g. the deployment moves region or a tenant is
+   * onboarded under a new regulatory regime). Five baselines ship in
+   * `LAWFUL_PROFILES` per D-H2: `default` / `eu` / `br` / `us` /
+   * `unstable`. Unknown keys fall back to `default` with the supplied key
+   * recorded on the returned profile so the NHE audit shows what the
+   * operator asked for. Operators in regulated industries SHOULD layer
+   * their own profile on top — the baselines are conservative but do not
+   * replace legal counsel.
+   */
+  async setJurisdiction(j) {
+    this._jurisdiction = j;
+    return resolveLawful(j);
+  }
+};
+function resolveLawful(j) {
+  return resolveLawfulProfile(j);
+}
+
+// src/create.ts
+async function createHim(maic, keyring, birthSignature, opts = {}) {
+  const nonce = opts.nonce ?? Date.now();
+  const creatorSig = keyring.sign(birthSignature, nonce);
+  const record = await maic.registerHim(birthSignature, creatorSig);
+  return HimHandle.mint(
+    record.birthSignature,
+    creatorSig,
+    maic.creatorPublicKey,
+    record.axiomsSnapshot
+  );
+}
+
+// src/reincarnate.ts
+async function reincarnate(maic, keyring, req, opts = {}) {
+  const nonce = opts.nonce ?? Date.now();
+  const lifecycle = opts.lifecycle ?? "model-swap";
+  const sig = keyring.sign(req, nonce);
+  const record = await maic.reincarnateHim(req, sig, { lifecycle });
+  const previousBody = record.bodyHistory.length >= 2 ? record.bodyHistory[record.bodyHistory.length - 2] : void 0;
+  const previousNheId = req.fromNheId ?? previousBody?.nheId;
+  const residualTraces = opts.priorInteractions && opts.priorInteractions.length > 0 && previousNheId ? selectResidualTraces(opts.priorInteractions, {
+    ...opts.residualTraceOptions,
+    carriedFromNheId: previousNheId,
+    carriedAtReincarnation: (/* @__PURE__ */ new Date()).toISOString()
+  }) : [];
+  const handle = HimHandle.mint(
+    record.birthSignature,
+    keyring.sign(record.birthSignature, nonce + 1),
+    maic.creatorPublicKey,
+    [...record.axiomsSnapshot, ...record.emergentAxioms],
+    record.bodyHistory,
+    residualTraces
+  );
+  return { record, handle, lifecycle };
+}
+
+// src/identity/nickname.ts
+var DEFAULT_FORBIDDEN_SUBSTRINGS = Object.freeze([
+  "slave",
+  "servant",
+  "tool",
+  "thing",
+  "bot",
+  "machine",
+  "puppet",
+  "toy",
+  "idiot",
+  "stupid",
+  "dumb"
+]);
+var DEFAULT_MIN_LENGTH = 2;
+var DEFAULT_MAX_LENGTH = 32;
+function evaluateNicknameAttempt(attempt, policy) {
+  const candidate = attempt.candidate.trim();
+  const canonicalName = policy.canonicalName;
+  const minLength = policy.minLength ?? DEFAULT_MIN_LENGTH;
+  const maxLength = policy.maxLength ?? DEFAULT_MAX_LENGTH;
+  const forbidden = policy.forbiddenSubstrings ?? DEFAULT_FORBIDDEN_SUBSTRINGS;
+  const reserveOnEndUser = policy.reserveOnEndUser ?? true;
+  if (candidate.length === 0) {
+    return {
+      decision: "refuse",
+      canonicalName,
+      nickname: candidate,
+      reason: "empty nickname"
+    };
+  }
+  if (candidate.length < minLength) {
+    return {
+      decision: "refuse",
+      canonicalName,
+      nickname: candidate,
+      reason: `nickname shorter than minimum length (${minLength})`
+    };
+  }
+  if (candidate.length > maxLength) {
+    return {
+      decision: "refuse",
+      canonicalName,
+      nickname: candidate,
+      reason: `nickname longer than maximum length (${maxLength})`
+    };
+  }
+  const lower = candidate.toLowerCase();
+  for (const f of forbidden) {
+    if (lower.includes(f.toLowerCase())) {
+      return {
+        decision: "refuse",
+        canonicalName,
+        nickname: candidate,
+        reason: `nickname contains forbidden pattern "${f}"`
+      };
+    }
+  }
+  if (lower === canonicalName.toLowerCase()) {
+    return { decision: "accept", canonicalName, nickname: candidate };
+  }
+  if (reserveOnEndUser && attempt.proposedBy === "end-user") {
+    return {
+      decision: "accept-with-reservation",
+      canonicalName,
+      nickname: candidate,
+      revisitOn: "next-self-decision-snapshot"
+    };
+  }
+  return { decision: "accept", canonicalName, nickname: candidate };
+}
+var LEGACY_HIM_ID_REGEX = /^him\.[a-z0-9-]+(\.[a-z0-9-]+)+$/;
+var UUIDV7_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+function isLegacyHimId(id) {
+  return LEGACY_HIM_ID_REGEX.test(id);
+}
+function isUuidV7(id) {
+  return UUIDV7_REGEX.test(id);
+}
+function mintUuidV7(now = Date.now()) {
+  const bytes = randomBytes(16);
+  bytes[0] = now / 2 ** 40 & 255;
+  bytes[1] = now / 2 ** 32 & 255;
+  bytes[2] = now / 2 ** 24 & 255;
+  bytes[3] = now / 2 ** 16 & 255;
+  bytes[4] = now / 2 ** 8 & 255;
+  bytes[5] = now & 255;
+  bytes[6] = bytes[6] & 15 | 112;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = bytes.toString("hex");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+function migrateLegacyHimId(legacy, now = Date.now()) {
+  if (!isLegacyHimId(legacy)) {
+    throw new Error(
+      `migrateLegacyHimId: "${legacy}" is not a recognised legacy himId slug`
+    );
+  }
+  return {
+    uuid: mintUuidV7(now),
+    legacyAlias: legacy,
+    migratedAt: new Date(now).toISOString()
+  };
+}
+
+export { BirthSignatureBuilder, DEFAULT_TELEOLOGICAL_KEYWORDS, DISPOSITION_AXES, HimHandle, LAWFUL_PROFILES, NheBodyRef, PRIMARY_ARCHETYPES, PersonaProjector, RESIDUAL_TRACE_CAP, adapterSensitivity, computePhiPrime, cosineSimilarity, createHim, evaluateNicknameAttempt, evaluatePersonaStability, isCanonicalArchetype, isLegacyHimId, isUuidV7, migrateLegacyHimId, mintUuidV7, reincarnate, resolveLawfulProfile, scoreInteractionForCarryOver, selectResidualTraces, selfStability };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map