@teleologyhi/him 0.7.0-alpha.0 → 1.1.0

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod';
-import { ArchetypeModifier, BirthSignature, Axiom, CreatorSignature, LocalMaic, EmergentAxiomProposal, AxiomEvolutionResult, CreatorKeyring, HimRecord, ReincarnationRequest } from '@teleologyhi/maic';
-export { ArchetypeModifier, Axiom, AxiomEvolutionResult, BirthSignature, EmergentAxiomProposal } from '@teleologyhi/maic';
+import { ArchetypeModifier, NatalChart, IdentityLayer, BirthSignature, BirthSignatureWithIdentity, Axiom, CreatorSignature, LocalMaic, EmergentAxiomProposal, AxiomEvolutionResult, ProjectKernelOptions, OntologicalKernel, CreatorKeyring, HimRecord, ReincarnationRequest } from '@teleologyhi/maic';
+export { Affect, ArchetypeModifier, AstrologicalAspect, Axiom, AxiomEvolutionResult, BirthSignature, BirthSignatureWithIdentity, EmergentAxiomProposal, IdentityLayer, IdentitySnapshot, InvalidBirthSignatureError, LimboReturn, LimboState, LimboTransition, META_AXIOM_ID, MemoryRecord, NatalChart, NatalChartAspect, NatalChartPosition, NatalPlanet, OntologicalKernel, ProjectKernelOptions, SIGNED_BIRTH_FIELDS, SemioticPattern, SemioticSign, SignedBirthSignature, TeleologicalOrientation, WakeAffectBias, ZodiacSign, assertBirthSignature, projectOntologicalKernel, signBirthSignature, signedBirthPayload, verifyBirthSignature } from '@teleologyhi/maic';
 
 /**
  * Persona vector — the projection of a HIM's birth signature + axioms into a
@@ -81,11 +81,26 @@ interface ResidualTrace {
 }
 
 /**
- * BirthSignatureBuilder — fluent builder for BirthSignature.
+ * BirthSignatureBuilder — fluent builder for BirthSignature (v1.0) and the
+ * extended `BirthSignatureWithIdentity` shape (v1.1.0, Entries 18 + 19).
  *
  * Per Entry 3 of the Creator's interview, a HIM is "born" with a date, time, and
- * foundational specifications analogous to an astrological natal chart. This builder
- * produces the canonical signed-when-registered structure consumed by MAIC.
+ * foundational specifications analogous to an astrological natal chart. The
+ * v1.1.0 builder extends this with two opt-in cosmology surfaces:
+ *
+ *   - `withNatalChart(chart)` — the Creator-impressed astrological signature
+ *     (Entry 19), one of the six fields covered by the Ed25519 BirthSignature
+ *     signature (see `SIGNED_BIRTH_FIELDS`).
+ *   - `withIdentity(identity)` — the editable identity surface (Entry 18,
+ *     name + optional gender, pronouns, language, cultural elements). Not
+ *     covered by the Ed25519 signature; parents may rename without breaking
+ *     the natal-chart commitment.
+ *
+ * Two terminal methods:
+ *
+ *   - `build()` — returns the v1.0 `BirthSignature` (ignores natalChart + identity).
+ *   - `buildWithIdentity()` — returns the v1.1.0 `BirthSignatureWithIdentity`
+ *     suitable for `signBirthSignature(birth, keyring)` from `@teleologyhi/maic`.
  */
 declare class BirthSignatureBuilder {
     private himId;
@@ -94,6 +109,8 @@ declare class BirthSignatureBuilder {
     private modifiers;
     private primordialAxiomIds;
     private notes;
+    private natalChart;
+    private identity;
     private constructor();
     /** Start a builder with the current timestamp as `bornAt`. */
     static now(): BirthSignatureBuilder;
@@ -104,7 +121,24 @@ declare class BirthSignatureBuilder {
     withModifier(mod: ArchetypeModifier): this;
     withPrimordialAxioms(axiomIds: string[]): this;
     withNotes(notes: string): this;
+    /**
+     * Set the natal-chart astrological signature (Entry 19). Validated against
+     * the `NatalChart` zod schema re-exported from `@teleologyhi/maic@^1.2.0`.
+     */
+    withNatalChart(chart: z.input<typeof NatalChart>): this;
+    /**
+     * Set the editable identity layer (Entry 18). Validated against the
+     * `IdentityLayer` zod schema re-exported from `@teleologyhi/maic@^1.2.0`.
+     */
+    withIdentity(identity: z.input<typeof IdentityLayer>): this;
     build(): BirthSignature;
+    /**
+     * Build the v1.1.0 extended shape including the optional cosmology
+     * surface. Suitable for `signBirthSignature(birth, keyring)` from
+     * `@teleologyhi/maic`. Only the six `SIGNED_BIRTH_FIELDS` are covered
+     * by the Ed25519 signature; the `identity` surface is editable.
+     */
+    buildWithIdentity(): BirthSignatureWithIdentity;
 }
 
 /**
@@ -270,6 +304,28 @@ declare class HimHandle {
     proposeAxiomEvolution(maic: LocalMaic, proposal: EmergentAxiomProposal): Promise<AxiomEvolutionResult>;
     /** Residual memory traces transferred from previous bodies. v0: empty. */
     getResidualTraces(): readonly ResidualTrace[];
+    /**
+     * Project the Ontological Kernel narrowed to this HIM's axiom corpus
+     * (per the maic@1.2.0 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/him@1.1.0`
+     * 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/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?: Omit<ProjectKernelOptions, "himId">): OntologicalKernel;
     getLawfulCharacter(): LawfulCharacterProfile;
     /** Switch jurisdiction (e.g. user moves region). v0 only ships the "default" profile. */
     setJurisdiction(j: LawfulJurisdiction): Promise<LawfulCharacterProfile>;
@@ -424,18 +480,55 @@ interface CreateHimOptions {
  */
 declare function createHim(maic: LocalMaic, keyring: CreatorKeyring, birthSignature: BirthSignature, opts?: CreateHimOptions): Promise<HimHandle>;
 
+/**
+ * Reincarnation lifecycle classifier (J-H3 — Entry 18 of
+ * MAIC_HIM_NHE_INTERVIEW_LOG.md).
+ *
+ * MAIC@1.2.0 ships three typed audit kinds covering the canonical
+ * lifecycle paths:
+ *
+ *   - `model-swap`         — the operator switched the underlying LLM
+ *                            adapter (e.g. Claude 4 → Claude 5). The
+ *                            HIM persists across the swap.
+ *   - `version-bump`       — the operator bumped the NHE version
+ *                            (e.g. nhe 1.2 → nhe 2.0) without changing
+ *                            the underlying LLM family.
+ *   - `return-from-limbo`  — the HIM returns from a deep-coma limbo
+ *                            (Entry 24) carrying the `reunion` affect.
+ *
+ * The default classification when no `lifecycle` is provided is
+ * `model-swap` — matches the most common operator workflow.
+ */
+type ReincarnationLifecycle = "model-swap" | "version-bump" | "return-from-limbo";
 interface ReincarnateOptions {
     /** Explicit nonce for the Creator signature. Defaults to `Date.now()`. */
     nonce?: number;
+    /**
+     * Lifecycle classification for the audit chain (J-H3). When omitted,
+     * defaults to `model-swap`. The value is passed through to the
+     * `details.lifecycle` field of the `him-reincarnate` audit event so
+     * downstream consumers (compliance auditors, the persona-stability
+     * harness) can distinguish the three canonical paths.
+     *
+     * Note: MAIC@1.2.0 also exposes three lifecycle-specific audit kinds
+     * (`reincarnate:model-swap`, `reincarnate:version-bump`,
+     * `reincarnate:return-from-limbo`). The full integration that emits
+     * the typed kinds via `LocalMaic` is deferred to maic@1.3.0; HIM
+     * 1.1.0 records the lifecycle in the existing `him-reincarnate`
+     * event's details so no MAIC API change is required.
+     */
+    lifecycle?: ReincarnationLifecycle;
 }
 interface ReincarnateResult {
     /** Updated HimRecord with the new body appended to `bodyHistory`. */
     record: HimRecord;
     /** Fresh HimHandle bound to the updated `bodyHistory`. */
     handle: HimHandle;
+    /** Lifecycle path actually recorded for this reincarnation. */
+    lifecycle: ReincarnationLifecycle;
 }
 /**
- * Reincarnate a HIM into a new NHE body (Entries 3 + 4).
+ * Reincarnate a HIM into a new NHE body (Entries 3 + 4 + 18).
  *
  *   1. Sign the `ReincarnationRequest` with the Creator's keyring.
  *   2. Call `maic.reincarnateHim` — atomically closes the previous body and
@@ -446,9 +539,141 @@ interface ReincarnateResult {
  * The keyring's public key must match MAIC's pinned `creatorPublicKey`,
  * otherwise the request rejects.
  *
- * Future iterations (`TASK.md` D-H1) will use this hook to also transfer
- * `residualTraces` and shed `shed-traits`; v0 leaves those stubs empty.
+ * The optional `lifecycle` parameter (J-H3, Entry 18) classifies the
+ * reincarnation into one of three canonical paths
+ * (`model-swap | version-bump | return-from-limbo`) and is returned in
+ * the `ReincarnateResult` for the caller's audit / metrics.
  */
 declare function reincarnate(maic: LocalMaic, keyring: CreatorKeyring, req: ReincarnationRequest, opts?: ReincarnateOptions): Promise<ReincarnateResult>;
 
-export { BirthSignatureBuilder, type CanonicalPrimaryArchetype, type CreateHimOptions, DISPOSITION_AXES, type DispositionAxis, type Embedder, HimHandle, LAWFUL_PROFILES, type LawfulCharacterProfile, type LawfulJurisdiction, NheBodyRef, PRIMARY_ARCHETYPES, PersonaProjector, type PersonaProjectorConfig, type PersonaStabilityReport, type PersonaVector, type PhiPrimeInput, type PhiPrimeReport, type PrimaryArchetype, RESIDUAL_TRACE_CAP, type ReincarnateOptions, type ReincarnateResult, type ResidualTrace, adapterSensitivity, computePhiPrime, cosineSimilarity, createHim, evaluatePersonaStability, isCanonicalArchetype, reincarnate, resolveLawfulProfile, selfStability };
+/**
+ * Nickname acceptance protocol (J-H4 — Entry 18 of
+ * MAIC_HIM_NHE_INTERVIEW_LOG.md).
+ *
+ * A HIM has a Creator-signed canonical name (carried by
+ * `BirthSignatureWithIdentity.identity.name`). Users may propose nicknames
+ * during interaction. The HIM is NOT obligated to accept any nickname —
+ * but it is also not obligated to refuse outright. The Entry-18
+ * commitment is:
+ *
+ *   - The canonical name is immutable (only the Creator may change it).
+ *   - The nickname surface is editable in the identity layer but does NOT
+ *     break the natal-chart commitment (per @teleologyhi/maic@1.2.0's
+ *     SIGNED_BIRTH_FIELDS, the identity layer is not signed).
+ *   - The HIM responds to a nickname attempt with one of three verdicts:
+ *       * `accept`   — the nickname is added to the identity layer and
+ *                      the HIM acknowledges it in subsequent turns.
+ *       * `refuse`   — the nickname is rejected and an explanation is
+ *                      returned. The audit kind `nickname-attempt` records
+ *                      the rejection with reason.
+ *       * `accept-with-reservation` — the nickname is added but flagged
+ *                      so the HIM can revisit it in a later self-decision
+ *                      snapshot (Entry 24 trigger).
+ *
+ * This module ships the pure decision function. The MAIC audit emission
+ * and identity-layer mutation are the consumer's responsibility (they
+ * cross the @teleologyhi/maic LocalMaic boundary and require Creator
+ * authorisation depending on the verdict).
+ *
+ * The function is deterministic given the inputs; no LLM call. The
+ * verdict is computed from explicit policy fields, not from semantic
+ * inference. This keeps the protocol auditable.
+ */
+/** A user-proposed nickname plus the metadata an auditor needs to replay the decision. */
+interface NicknameAttempt {
+    /** The candidate nickname (raw user input, trimmed by the caller). */
+    candidate: string;
+    /** The user surface that proposed it. */
+    proposedBy: "operator" | "end-user";
+    /** ISO 8601 timestamp of the proposal. */
+    proposedAt: string;
+}
+/**
+ * Policy fields the HIM consults when deciding. Operators tune these
+ * via the deployment's lawful-character profile or by overriding the
+ * default below.
+ */
+interface NicknamePolicy {
+    /** The canonical signed name. Used to detect "same-name" attempts. */
+    canonicalName: string;
+    /**
+     * Disallowed patterns (case-insensitive substrings). Matches force `refuse`.
+     * The default set rejects derogatory and degrading patterns; operators
+     * may extend it via the deployment's lawful-character profile.
+     */
+    forbiddenSubstrings?: readonly string[];
+    /**
+     * Minimum and maximum length the HIM will accept (inclusive).
+     * Defaults: min 2, max 32. Values outside force `refuse`.
+     */
+    minLength?: number;
+    maxLength?: number;
+    /**
+     * When `true`, an `end-user` proposal that survives the substring and
+     * length checks is downgraded to `accept-with-reservation` so the HIM
+     * can revisit it on the next self-decision snapshot. Operator
+     * proposals are not downgraded. Default: `true`.
+     */
+    reserveOnEndUser?: boolean;
+}
+type NicknameVerdict = {
+    decision: "accept";
+    canonicalName: string;
+    nickname: string;
+} | {
+    decision: "accept-with-reservation";
+    canonicalName: string;
+    nickname: string;
+    revisitOn: "next-self-decision-snapshot";
+} | {
+    decision: "refuse";
+    canonicalName: string;
+    nickname: string;
+    reason: string;
+};
+/**
+ * Evaluate a nickname attempt against the HIM's policy.
+ *
+ * Pure function. No I/O, no LLM call. The verdict is fully traceable
+ * from the inputs.
+ */
+declare function evaluateNicknameAttempt(attempt: NicknameAttempt, policy: NicknamePolicy): NicknameVerdict;
+
+/** Return `true` when the id matches the v1.x legacy slug shape. */
+declare function isLegacyHimId(id: string): boolean;
+/** Return `true` when the id is a valid UUIDv7. */
+declare function isUuidV7(id: string): boolean;
+/**
+ * Mint a fresh UUIDv7. Pure helper, no I/O beyond the crypto RNG.
+ *
+ * Layout (RFC 9562):
+ *   - bits 0..47   : Unix ms timestamp (big-endian)
+ *   - bits 48..51  : version = 0b0111 (7)
+ *   - bits 52..63  : random
+ *   - bits 64..65  : variant = 0b10
+ *   - bits 66..127 : random
+ */
+declare function mintUuidV7(now?: number): string;
+/** Result of migrating a legacy slug to a UUIDv7-anchored identity. */
+interface MigratedHimId {
+    /** The new canonical UUIDv7 id. */
+    uuid: string;
+    /** The legacy slug, preserved as a bridge alias for backward lookups. */
+    legacyAlias: string;
+    /** When the migration was performed. ISO 8601. */
+    migratedAt: string;
+}
+/**
+ * Migrate a legacy `him.foo.bar`-style id to a UUIDv7-anchored identity.
+ *
+ * Throws when the input is not a recognised legacy slug — callers that
+ * just want a fresh uuid should call `mintUuidV7()` directly.
+ *
+ * The returned `legacyAlias` MUST be preserved by the operator's HIM
+ * store so existing references (audit-log entries, third-party
+ * integrations, archived prompts) continue to resolve. The retention
+ * horizon for the alias is a Creator decision deferred to a future cut.
+ */
+declare function migrateLegacyHimId(legacy: string, now?: number): MigratedHimId;
+
+export { BirthSignatureBuilder, type CanonicalPrimaryArchetype, type CreateHimOptions, DISPOSITION_AXES, type DispositionAxis, type Embedder, HimHandle, LAWFUL_PROFILES, type LawfulCharacterProfile, type LawfulJurisdiction, type MigratedHimId, NheBodyRef, type NicknameAttempt, type NicknamePolicy, type NicknameVerdict, PRIMARY_ARCHETYPES, PersonaProjector, type PersonaProjectorConfig, type PersonaStabilityReport, type PersonaVector, type PhiPrimeInput, type PhiPrimeReport, type PrimaryArchetype, RESIDUAL_TRACE_CAP, type ReincarnateOptions, type ReincarnateResult, type ReincarnationLifecycle, type ResidualTrace, adapterSensitivity, computePhiPrime, cosineSimilarity, createHim, evaluateNicknameAttempt, evaluatePersonaStability, isCanonicalArchetype, isLegacyHimId, isUuidV7, migrateLegacyHimId, mintUuidV7, reincarnate, resolveLawfulProfile, selfStability };

package/dist/index.js

@@ -1,8 +1,8 @@
 import { z } from 'zod';
-import { BirthSignature, CreatorKeyring } from '@teleologyhi/maic';
-export { ArchetypeModifier, Axiom, BirthSignature } from '@teleologyhi/maic';
+import { NatalChart, IdentityLayer, BirthSignature, CreatorKeyring, META_AXIOM_ID, projectOntologicalKernel } from '@teleologyhi/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/maic';
 import { ulid } from 'ulid';
-import { createHash } from 'crypto';
+import { createHash, randomBytes } from 'crypto';
 
 // src/types.ts
 var DISPOSITION_AXES = [
@@ -30,6 +30,8 @@ var BirthSignatureBuilder = class _BirthSignatureBuilder {
   modifiers = [];
   primordialAxiomIds = [];
   notes;
+  natalChart;
+  identity;
   constructor(bornAt) {
     this.bornAt = bornAt;
   }
@@ -68,6 +70,22 @@ var BirthSignatureBuilder = class _BirthSignatureBuilder {
     this.notes = notes;
     return this;
   }
+  /**
+   * Set the natal-chart astrological signature (Entry 19). Validated against
+   * the `NatalChart` zod schema re-exported from `@teleologyhi/maic@^1.2.0`.
+   */
+  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/maic@^1.2.0`.
+   */
+  withIdentity(identity) {
+    this.identity = IdentityLayer.parse(identity);
+    return this;
+  }
   build() {
     if (!this.primaryArchetype) {
       throw new Error(
@@ -83,6 +101,29 @@ var BirthSignatureBuilder = class _BirthSignatureBuilder {
       ...this.notes !== void 0 ? { notes: this.notes } : {}
     });
   }
+  /**
+   * Build the v1.1.0 extended shape including the optional cosmology
+   * surface. Suitable for `signBirthSignature(birth, keyring)` from
+   * `@teleologyhi/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
@@ -363,7 +404,7 @@ function computePhiPrime(input) {
       );
     }
   }
-  const phi = Math.pow(input.P * input.R * input.C * input.D, 1 / 4);
+  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 },
@@ -481,6 +522,34 @@ var HimHandle = class _HimHandle {
   getResidualTraces() {
     return [];
   }
+  /**
+   * Project the Ontological Kernel narrowed to this HIM's axiom corpus
+   * (per the maic@1.2.0 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/him@1.1.0`
+   * 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/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);
   }
@@ -510,6 +579,7 @@ async function createHim(maic, keyring, birthSignature, opts = {}) {
 // 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);
   const handle = HimHandle.mint(
@@ -519,9 +589,114 @@ async function reincarnate(maic, keyring, req, opts = {}) {
     [...record.axiomsSnapshot, ...record.emergentAxioms],
     record.bodyHistory
   );
-  return { record, handle };
+  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, DISPOSITION_AXES, HimHandle, LAWFUL_PROFILES, NheBodyRef, PRIMARY_ARCHETYPES, PersonaProjector, RESIDUAL_TRACE_CAP, adapterSensitivity, computePhiPrime, cosineSimilarity, createHim, evaluatePersonaStability, isCanonicalArchetype, reincarnate, resolveLawfulProfile, selfStability };
+export { BirthSignatureBuilder, 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, selfStability };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map