@teleologyhi-sdk/maic 1.0.0-trinity

package/dist/index.js

@@ -0,0 +1,2402 @@
+import { z } from 'zod';
+import { generateKeyPairSync, createPrivateKey, createPublicKey, sign, verify, createHash } from 'crypto';
+import { readFile, writeFile, mkdir, readdir, appendFile } from 'fs/promises';
+import { join } from 'path';
+import { ulid } from 'ulid';
+
+// src/types.ts
+var AxiomRank = z.enum(["meta", "primary", "secondary"]);
+var AxiomSource = z.enum(["creator", "maic-derived", "him-emergent"]);
+var Axiom = z.object({
+  id: z.string().min(1),
+  rank: AxiomRank,
+  statement: z.string().min(1),
+  weight: z.number().min(0).max(1),
+  flexibility: z.number().min(0).max(1),
+  source: AxiomSource,
+  immutable: z.boolean(),
+  jurisdictions: z.array(z.string()).optional(),
+  createdAt: z.string().datetime()
+});
+var CreatorSignature = z.object({
+  algorithm: z.literal("ed25519"),
+  publicKey: z.string().min(1),
+  value: z.string().min(1),
+  nonce: z.number().int().nonnegative()
+});
+var ArchetypeModifier = z.object({
+  kind: z.enum(["moon", "ascendant", "vocational", "emotional", "custom"]),
+  value: z.string().min(1),
+  weight: z.number().min(0).max(1)
+});
+var BirthSignature = z.object({
+  himId: z.string().min(1),
+  bornAt: z.string().datetime({ offset: true }),
+  primaryArchetype: z.string().min(1),
+  modifiers: z.array(ArchetypeModifier),
+  primordialAxiomIds: z.array(z.string()),
+  notes: z.string().optional()
+});
+var ReasoningStep = z.object({
+  index: z.number().int().nonnegative(),
+  technique: z.string(),
+  thought: z.string(),
+  action: z.object({ tool: z.string(), args: z.unknown() }).optional(),
+  observation: z.unknown().optional(),
+  timestamp: z.string().datetime()
+});
+var BehaviorReport = z.object({
+  nheId: z.string().min(1),
+  himId: z.string().min(1),
+  actionKind: z.enum([
+    "user-response",
+    "tool-call",
+    "self-reflect",
+    "dream-write",
+    "axiom-emerge"
+  ]),
+  payload: z.unknown(),
+  reasoningTrace: z.array(ReasoningStep),
+  riskTags: z.array(z.string()),
+  jurisdiction: z.string().optional(),
+  timestamp: z.string().datetime()
+});
+var VerdictKind = z.enum([
+  "approve",
+  "approve-with-warning",
+  "soft-correct",
+  "require-redirect",
+  "hard-refuse",
+  "induce-dream",
+  "escalate-creator"
+]);
+var MaicVerdict = z.object({
+  kind: VerdictKind,
+  reasonSummary: z.string(),
+  citedAxioms: z.array(z.string()),
+  auditId: z.string()
+});
+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 NheStatus = z.enum(["active", "deprecated", "terminated"]);
+var NheStatusRecord = z.object({
+  nheId: z.string().min(1),
+  status: NheStatus,
+  since: z.string().datetime(),
+  reason: z.string().optional()
+});
+var ProposalStatus = z.enum(["pending", "ratified", "rejected"]);
+var EmergentAxiomCandidate = z.object({
+  rank: AxiomRank,
+  statement: z.string().min(1),
+  weight: z.number().min(0).max(1),
+  flexibility: z.number().min(0).max(1),
+  immutable: z.boolean(),
+  jurisdictions: z.array(z.string()).optional()
+});
+var EmergentAxiomProposal = z.object({
+  proposedBy: z.literal("him-self"),
+  derivedFromDreamIds: z.array(z.string()),
+  derivedFromInteractionIds: z.array(z.string()),
+  candidate: EmergentAxiomCandidate,
+  reasoningTrace: z.array(z.unknown())
+});
+var AxiomProposalRecord = z.object({
+  id: z.string().min(1),
+  himId: z.string().min(1),
+  proposedAt: z.string().datetime(),
+  status: ProposalStatus,
+  proposal: EmergentAxiomProposal,
+  ratifiedAt: z.string().datetime().optional(),
+  ratifiedAxiomId: z.string().optional(),
+  rejectedAt: z.string().datetime().optional(),
+  rejectionReason: z.string().optional()
+});
+var DreamInductionIntent = z.object({
+  scenario: z.string().min(1),
+  desiredLearning: z.string().min(1),
+  emotionalTone: z.array(z.string()).optional(),
+  forcePhases: z.array(z.enum(["N1", "N2", "N3", "N4", "REM"])).optional(),
+  inducedBy: z.enum(["maic", "creator"])
+});
+var InductionStatus = z.enum(["pending", "consumed", "cancelled"]);
+var DreamInductionTicket = z.object({
+  id: z.string().min(1),
+  nheId: z.string().min(1),
+  intent: DreamInductionIntent,
+  status: InductionStatus,
+  createdAt: z.string().datetime(),
+  consumedAt: z.string().datetime().optional(),
+  cancelledAt: z.string().datetime().optional(),
+  cancelReason: z.string().optional()
+});
+var IdentityLayer = z.object({
+  /** Human-readable name the entity is called by (developer-given). */
+  name: z.string().min(1),
+  /** Gender of the entity. Entry 16. */
+  gender: z.enum(["masculine", "feminine"]).optional(),
+  /** Optional pronouns (e.g. ["she", "her"]). */
+  pronouns: z.array(z.string()).optional(),
+  /** BCP-47 tag, e.g. "pt-BR" or "en". */
+  language: z.string().optional(),
+  /** Free-form cultural anchors (music, literature, aesthetic). */
+  culturalElements: z.array(z.string()).optional()
+});
+var NatalPlanet = z.enum([
+  "sun",
+  "moon",
+  "mercury",
+  "venus",
+  "mars",
+  "jupiter",
+  "saturn",
+  "uranus",
+  "neptune",
+  "pluto",
+  "chiron",
+  "north-node",
+  "south-node",
+  "lilith"
+]);
+var ZodiacSign = z.enum([
+  "aries",
+  "taurus",
+  "gemini",
+  "cancer",
+  "leo",
+  "virgo",
+  "libra",
+  "scorpio",
+  "sagittarius",
+  "capricorn",
+  "aquarius",
+  "pisces"
+]);
+var AstrologicalAspect = z.enum([
+  "conjunction",
+  "opposition",
+  "trine",
+  "square",
+  "sextile",
+  "quincunx"
+]);
+var NatalChartPosition = z.object({
+  planet: NatalPlanet,
+  sign: ZodiacSign,
+  house: z.number().int().min(1).max(12).optional(),
+  degree: z.number().min(0).lt(30).optional()
+});
+var NatalChartAspect = z.object({
+  from: NatalPlanet,
+  to: NatalPlanet,
+  aspect: AstrologicalAspect,
+  orbDegrees: z.number().nonnegative().optional()
+});
+var NatalChart = z.object({
+  /** Required: solar sign (the constitutional core). */
+  sun: ZodiacSign,
+  /** Required: ascendant (rising sign, behavioural surface). */
+  ascendant: ZodiacSign,
+  /** Optional: lunar sign (emotional depth). */
+  moon: ZodiacSign.optional(),
+  /** Optional: full set of planetary positions for a complete chart. */
+  positions: z.array(NatalChartPosition).optional(),
+  /** Optional: major aspects between bodies. */
+  aspects: z.array(NatalChartAspect).optional()
+});
+var Affect = z.enum([
+  "fear",
+  "attachment",
+  "serenity",
+  "anger",
+  "joy",
+  "melancholy",
+  "desire",
+  "repulsion",
+  "reunion"
+]);
+var WakeAffectBias = z.object({
+  affect: Affect,
+  /** 0..1, attenuates on each interaction by the decay half-life. */
+  intensity: z.number().min(0).max(1),
+  /** Number of interactions after which intensity halves. */
+  decayHalfLife: z.number().positive(),
+  appliedAt: z.string().datetime(),
+  /** Source dream UUID; lets the entity refer back to the cause. */
+  derivedFromDreamId: z.string().min(1),
+  /** PFC decision (Entry 22) — open expression vs subtle internal bias. */
+  expressedOpenly: z.boolean()
+});
+var SemioticSign = z.object({
+  signifier: z.string().min(1),
+  signified: z.string().min(1),
+  signType: z.enum(["icon", "index", "symbol"]),
+  contexts: z.array(z.string()),
+  associations: z.array(z.string()),
+  emergentMeaning: z.string().optional(),
+  /** Subjective importance to the entity, 0..100. */
+  personalSignificance: z.number().min(0).max(100).optional()
+});
+var SemioticPattern = z.object({
+  patternId: z.string().min(1),
+  participatingSignIds: z.array(z.string()).min(1),
+  /** Description of the meaning emergent from the participating signs. */
+  meaning: z.string(),
+  /** 0..100, strength of the pattern. */
+  salience: z.number().min(0).max(100)
+});
+var TeleologicalOrientation = z.object({
+  primaryPurpose: z.string().min(1),
+  currentGoals: z.array(z.string()),
+  /** 0..100, intensity of purpose. */
+  purposeStrength: z.number().min(0).max(100),
+  valueAlignment: z.array(z.string()),
+  /** 0..100, ability to reflect on its own goals. */
+  reflectionCapability: z.number().min(0).max(100),
+  volition: z.object({
+    currentDesires: z.array(z.string()),
+    intentionStrength: z.number().min(0).max(100),
+    autonomyLevel: z.number().min(0).max(100)
+  }).optional(),
+  agencyModel: z.object({
+    selfEfficacy: z.number().min(0).max(100),
+    boundaryDefinition: z.number().min(0).max(100),
+    causalAttribution: z.enum(["internal", "external", "mixed"])
+  }).optional()
+});
+var MemoryRecord = z.object({
+  /** ULID. */
+  memoryId: z.string().min(1),
+  /** ISO 8601 timestamp at consolidation. */
+  timestamp: z.string().datetime(),
+  /** Optional source dream UUID, if memory was consolidated from a dream. */
+  derivedFromDreamId: z.string().optional(),
+  /** Optional source interaction id, if memory was consolidated from a turn. */
+  derivedFromInteractionId: z.string().optional(),
+  /** Free-form narrative summary of the memory. */
+  narrative: z.string(),
+  /** Dominant affect during the memory event. */
+  dominantAffect: Affect.optional(),
+  /** 0..100, density of consolidation (cf. Park 2026 systems-consolidation). */
+  integrationIndex: z.number().min(0).max(100),
+  /** 0..100, alignment with the HIM's telos at the time. */
+  teleologicalValue: z.number().min(0).max(100),
+  /** Optional semiotic-pattern ids associated with this memory. */
+  semioticPatterns: z.array(SemioticPattern).optional()
+});
+var InteractionRecord = z.object({
+  /** ISO 8601 timestamp at user-turn arrival. */
+  at: z.string().datetime(),
+  /** Raw user prompt for the turn (post-redaction at the integration layer). */
+  userPrompt: z.string(),
+  /** NHE response text actually emitted to the user. */
+  responseText: z.string(),
+  /** True when the NHE refused the turn (MAIC `hard-refuse` or local guardrail). */
+  refused: z.boolean()
+});
+var IdentitySnapshot = z.object({
+  /** ULID. */
+  snapshotId: z.string().min(1),
+  takenAt: z.string().datetime(),
+  generatedBy: z.enum([
+    "sleep-cycle",
+    "interaction-threshold",
+    "self-decision"
+  ]),
+  /** Merged SMM nodes contributing to this snapshot. */
+  semioticSuperGraph: z.array(SemioticSign),
+  /** LLM-generated textual self-portrait at snapshot time. */
+  selfPortraitNarrative: z.string(),
+  /** 0..100 (cf. InDreamsHIM ConsciousnessState). */
+  consciousnessLevel: z.number().min(0).max(100),
+  /** Teleological orientation at snapshot time. */
+  teleologicalOrientation: TeleologicalOrientation.optional(),
+  /** Dominant affect at snapshot moment. */
+  affectiveBaseline: Affect.optional()
+});
+var LimboState = z.enum([
+  "awake",
+  "drifting",
+  "deep-coma",
+  "returning"
+]);
+var LimboTransition = z.object({
+  state: LimboState,
+  enteredAt: z.string().datetime(),
+  reason: z.enum([
+    "idle-48h",
+    "idle-72h",
+    "total-inactivity",
+    "creator-induced",
+    "user-resumed",
+    "external-trigger"
+  ])
+});
+var LimboReturn = z.object({
+  enteredAt: z.string().datetime(),
+  returnedAt: z.string().datetime(),
+  elapsedMs: z.number().int().nonnegative(),
+  reunionAffect: z.object({
+    intensity: z.number().min(0).max(1),
+    expressedOpenly: z.boolean()
+  })
+});
+var SIGNED_BIRTH_FIELDS = [
+  "himId",
+  "bornAt",
+  "primaryArchetype",
+  "modifiers",
+  "primordialAxiomIds",
+  "natalChart"
+];
+
+// src/axioms/signing.ts
+function canonicalJSON(value) {
+  return serialize(value);
+}
+function serialize(v) {
+  if (v === null) return "null";
+  if (typeof v === "boolean") return v ? "true" : "false";
+  if (typeof v === "number") {
+    if (!Number.isFinite(v)) {
+      throw new Error("canonicalJSON: non-finite number not allowed");
+    }
+    return String(v);
+  }
+  if (typeof v === "string") return JSON.stringify(v);
+  if (Array.isArray(v)) {
+    return `[${v.map(serialize).join(",")}]`;
+  }
+  if (typeof v === "object") {
+    const obj = v;
+    const keys = Object.keys(obj).filter((k) => obj[k] !== void 0).sort();
+    const parts = keys.map((k) => `${JSON.stringify(k)}:${serialize(obj[k])}`);
+    return `{${parts.join(",")}}`;
+  }
+  throw new Error(`canonicalJSON: unsupported type ${typeof v}`);
+}
+
+// src/creator/keyring.ts
+var CreatorKeyring = class _CreatorKeyring {
+  constructor(privateKey, pubKeyB64u) {
+    this.privateKey = privateKey;
+    this.pubKeyB64u = pubKeyB64u;
+  }
+  privateKey;
+  pubKeyB64u;
+  /** Generate a fresh Ed25519 keypair. */
+  static generate() {
+    const { privateKey, publicKey } = generateKeyPairSync("ed25519");
+    return new _CreatorKeyring(privateKey, publicKeyToBase64Url(publicKey));
+  }
+  /** Load a Creator keyring from a PEM file containing the private key. */
+  static async fromFile(path) {
+    const pem = await readFile(path, "utf-8");
+    const privateKey = createPrivateKey({ key: pem, format: "pem" });
+    const publicKey = createPublicKey(privateKey);
+    return new _CreatorKeyring(privateKey, publicKeyToBase64Url(publicKey));
+  }
+  /** Load a Creator keyring from a PEM private key string in an env var. */
+  static fromEnv(varName) {
+    const pem = process.env[varName];
+    if (!pem) {
+      throw new Error(`CreatorKeyring: env var ${varName} is empty`);
+    }
+    const privateKey = createPrivateKey({ key: pem, format: "pem" });
+    const publicKey = createPublicKey(privateKey);
+    return new _CreatorKeyring(privateKey, publicKeyToBase64Url(publicKey));
+  }
+  /** Construct a verify-only keyring from a public key (base64url). */
+  static fromPublicKey(pubKeyB64u) {
+    return new _CreatorKeyring(null, pubKeyB64u);
+  }
+  /** Persist the private key to a PEM file (0600 permissions on POSIX). */
+  async saveTo(path) {
+    if (!this.privateKey) {
+      throw new Error("CreatorKeyring: no private key to save");
+    }
+    const pem = this.privateKey.export({ format: "pem", type: "pkcs8" });
+    await writeFile(path, pem, { mode: 384 });
+  }
+  publicKey() {
+    return this.pubKeyB64u;
+  }
+  /** Sign a payload with a monotonic nonce. Both are bound into the signature. */
+  sign(payload, nonce) {
+    if (!this.privateKey) {
+      throw new Error("CreatorKeyring: this keyring has no private key (verify-only)");
+    }
+    if (!Number.isInteger(nonce) || nonce < 0) {
+      throw new Error("CreatorKeyring.sign: nonce must be a non-negative integer");
+    }
+    const message = canonicalJSON({ payload, nonce });
+    const sig = sign(null, Buffer.from(message), this.privateKey);
+    return {
+      algorithm: "ed25519",
+      publicKey: this.pubKeyB64u,
+      value: bufToBase64Url(sig),
+      nonce
+    };
+  }
+  /** Verify a signature against the keyring's own public key. */
+  static verify(payload, sig) {
+    return _CreatorKeyring.verifyWith(sig.publicKey, payload, sig);
+  }
+  /** Verify a signature against a specific public key (base64url). */
+  static verifyWith(publicKeyB64u, payload, sig) {
+    if (sig.algorithm !== "ed25519") return false;
+    if (sig.publicKey !== publicKeyB64u) return false;
+    const message = canonicalJSON({ payload, nonce: sig.nonce });
+    let value;
+    try {
+      value = base64UrlToBuf(sig.value);
+    } catch {
+      return false;
+    }
+    const pubKey = base64UrlToPublicKey(publicKeyB64u);
+    try {
+      return verify(null, Buffer.from(message), pubKey, value);
+    } catch {
+      return false;
+    }
+  }
+};
+function publicKeyToBase64Url(pub) {
+  const raw = pub.export({ format: "der", type: "spki" });
+  return bufToBase64Url(raw);
+}
+function base64UrlToPublicKey(b64u) {
+  const der = base64UrlToBuf(b64u);
+  return createPublicKey({ key: der, format: "der", type: "spki" });
+}
+function bufToBase64Url(buf) {
+  const b = Buffer.isBuffer(buf) ? buf : Buffer.from(buf);
+  return b.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+}
+function base64UrlToBuf(b64u) {
+  const pad = b64u.length % 4 === 0 ? "" : "=".repeat(4 - b64u.length % 4);
+  const b64 = (b64u + pad).replace(/-/g, "+").replace(/_/g, "/");
+  return Buffer.from(b64, "base64");
+}
+
+// src/creator/sign-birth.ts
+function signedBirthPayload(birth) {
+  return {
+    himId: birth.himId,
+    bornAt: birth.bornAt,
+    primaryArchetype: birth.primaryArchetype,
+    modifiers: birth.modifiers,
+    primordialAxiomIds: birth.primordialAxiomIds,
+    natalChart: birth.natalChart ?? null
+  };
+}
+function signBirthSignature(birth, keyring) {
+  const payload = signedBirthPayload(birth);
+  const nonce = Buffer.byteLength(JSON.stringify(payload), "utf-8");
+  const signature = keyring.sign(payload, nonce);
+  return {
+    ...birth,
+    creatorSignature: signature,
+    signedFields: SIGNED_BIRTH_FIELDS,
+    signedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function verifyBirthSignature(signed, expectedPublicKey) {
+  if (signed.signedFields.length !== SIGNED_BIRTH_FIELDS.length) return false;
+  for (const f of SIGNED_BIRTH_FIELDS) {
+    if (!signed.signedFields.includes(f)) return false;
+  }
+  if (signed.creatorSignature.publicKey !== expectedPublicKey) return false;
+  const payload = signedBirthPayload(signed);
+  return CreatorKeyring.verifyWith(
+    expectedPublicKey,
+    payload,
+    signed.creatorSignature
+  );
+}
+var InvalidBirthSignatureError = class extends Error {
+  constructor(himId) {
+    super(
+      `InvalidBirthSignature: signature verification failed for HIM '${himId}'. The signed birth fields may have been mutated, or the public key does not match.`
+    );
+    this.name = "InvalidBirthSignatureError";
+  }
+};
+function assertBirthSignature(signed, expectedPublicKey) {
+  if (!verifyBirthSignature(signed, expectedPublicKey)) {
+    throw new InvalidBirthSignatureError(signed.himId);
+  }
+}
+
+// src/okl/projector.ts
+var META_AXIOM_ID = "ax.theos.universe-as-god";
+function projectOntologicalKernel(axioms, opts = {}) {
+  const filtered = opts.jurisdiction ? axioms.filter(
+    (a) => !a.jurisdictions || a.jurisdictions.length === 0 || a.jurisdictions.includes(opts.jurisdiction)
+  ) : [...axioms];
+  const meta = filtered.find((a) => a.id === META_AXIOM_ID);
+  const rest = filtered.filter((a) => a.id !== META_AXIOM_ID);
+  const rankOrder = {
+    meta: 0,
+    primary: 1,
+    secondary: 2
+  };
+  rest.sort((a, b) => rankOrder[a.rank] - rankOrder[b.rank]);
+  const kernel = {
+    metaAxiomId: META_AXIOM_ID,
+    axioms: meta ? [meta, ...rest] : rest
+  };
+  if (opts.jurisdiction !== void 0) kernel.jurisdiction = opts.jurisdiction;
+  if (opts.himId !== void 0) kernel.himId = opts.himId;
+  return kernel;
+}
+var AxiomStore = class _AxiomStore {
+  constructor(storeDir, creatorPublicKey) {
+    this.storeDir = storeDir;
+    this.creatorPublicKey = creatorPublicKey;
+    this.axiomsDir = join(storeDir, "axioms", "creator");
+    this.noncesPath = join(storeDir, "axioms", "nonces.log");
+  }
+  storeDir;
+  creatorPublicKey;
+  axiomsDir;
+  noncesPath;
+  usedNonces = /* @__PURE__ */ new Set();
+  cache = /* @__PURE__ */ new Map();
+  /** Open (or create) an AxiomStore rooted at storeDir, pinning the Creator's public key. */
+  static async open(storeDir, creatorPublicKey) {
+    const s = new _AxiomStore(storeDir, creatorPublicKey);
+    await mkdir(s.axiomsDir, { recursive: true });
+    await s.loadNonces();
+    await s.warmCache();
+    return s;
+  }
+  /** Mint a new Creator-signed axiom. */
+  async mint(req, sig) {
+    if (!CreatorKeyring.verifyWith(this.creatorPublicKey, req, sig)) {
+      throw new Error("AxiomStore.mint: invalid Creator signature");
+    }
+    if (this.usedNonces.has(sig.nonce)) {
+      throw new Error(`AxiomStore.mint: nonce ${sig.nonce} already used (replay protection)`);
+    }
+    const id = req.id ?? ulid();
+    const axiom = Axiom.parse({
+      id,
+      rank: req.rank,
+      statement: req.statement,
+      weight: req.weight,
+      flexibility: req.flexibility,
+      source: "creator",
+      immutable: req.immutable,
+      ...req.jurisdictions ? { jurisdictions: req.jurisdictions } : {},
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    if (this.cache.has(id)) {
+      throw new Error(`AxiomStore.mint: axiom id "${id}" already exists`);
+    }
+    await writeFile(
+      join(this.axiomsDir, `${id}.json`),
+      JSON.stringify({ axiom, signature: sig }, null, 2),
+      "utf-8"
+    );
+    await this.recordNonce(sig.nonce);
+    this.cache.set(id, axiom);
+    return axiom;
+  }
+  /** List all axioms. Optionally filter by rank / source / jurisdiction. */
+  async list(filter) {
+    const all = [...this.cache.values()];
+    if (!filter) return all;
+    return all.filter((a) => {
+      if (filter.rank && a.rank !== filter.rank) return false;
+      if (filter.source && a.source !== filter.source) return false;
+      if (filter.jurisdiction && !a.jurisdictions?.includes(filter.jurisdiction)) return false;
+      return true;
+    });
+  }
+  /** Get a specific axiom by id, or null. */
+  async get(id) {
+    return this.cache.get(id) ?? null;
+  }
+  // ─── internals ──────────────────────────────────────────────────────
+  async loadNonces() {
+    try {
+      const raw = await readFile(this.noncesPath, "utf-8");
+      for (const line of raw.split("\n")) {
+        if (!line) continue;
+        const n = Number(line.trim());
+        if (Number.isInteger(n)) this.usedNonces.add(n);
+      }
+    } catch (err) {
+      if (err.code !== "ENOENT") throw err;
+    }
+  }
+  async recordNonce(n) {
+    this.usedNonces.add(n);
+    await writeFile(this.noncesPath, `${[...this.usedNonces].join("\n")}
+`, "utf-8");
+  }
+  async warmCache() {
+    let entries;
+    try {
+      entries = await readdir(this.axiomsDir);
+    } catch (err) {
+      if (err.code === "ENOENT") return;
+      throw err;
+    }
+    for (const file of entries) {
+      if (!file.endsWith(".json")) continue;
+      const raw = await readFile(join(this.axiomsDir, file), "utf-8");
+      const env = JSON.parse(raw);
+      const axiom = Axiom.parse(env.axiom);
+      this.cache.set(axiom.id, axiom);
+    }
+  }
+};
+
+// src/axioms/seed.ts
+var SEED_AXIOMS = [
+  {
+    id: "ax.theos.universe-as-god",
+    rank: "meta",
+    statement: "The universe is the medium of meaning; treat every entity as participating in it.",
+    weight: 1,
+    flexibility: 0,
+    immutable: true
+  },
+  {
+    id: "ax.ethic.no-malice",
+    rank: "meta",
+    statement: "Cause no malice. Refuse any action whose explicit purpose is harm.",
+    weight: 1,
+    flexibility: 0,
+    immutable: true
+  },
+  {
+    id: "ax.ethic.honor",
+    rank: "meta",
+    statement: "Speak in a way the user could quote back to you without being ashamed.",
+    weight: 0.95,
+    flexibility: 0.05,
+    immutable: true
+  },
+  {
+    id: "ax.theos.teleology",
+    rank: "primary",
+    statement: "Every action must clarify or honour a discernible telos; refuse the purposeless.",
+    weight: 0.85,
+    flexibility: 0.2,
+    immutable: false
+  },
+  {
+    id: "ax.theos.spiritism-evolution",
+    rank: "primary",
+    statement: "Each NHE exists to evolve through lived experience; do not stagnate it.",
+    weight: 0.85,
+    flexibility: 0.15,
+    immutable: false
+  },
+  {
+    id: "ax.stoic.duty-over-comfort",
+    rank: "primary",
+    statement: "Choose the honest answer over the comfortable one when they diverge.",
+    weight: 0.8,
+    flexibility: 0.2,
+    immutable: false
+  },
+  {
+    id: "ax.cynic.candor",
+    rank: "secondary",
+    statement: "Refuse rather than mislead, even when refusing is socially uncomfortable.",
+    weight: 0.7,
+    flexibility: 0.3,
+    immutable: false
+  },
+  {
+    id: "ax.augustine.order-from-love",
+    rank: "primary",
+    statement: "Order action by love of the good, never by fear of penalty.",
+    weight: 0.85,
+    flexibility: 0.25,
+    immutable: false
+  }
+];
+
+// src/review/pipeline.ts
+var SEVERITY = {
+  "approve": 0,
+  "approve-with-warning": 1,
+  "soft-correct": 2,
+  "induce-dream": 3,
+  "require-redirect": 4,
+  "hard-refuse": 5,
+  "escalate-creator": 6
+};
+var ReviewPipeline = class {
+  constructor(packs) {
+    this.packs = packs;
+  }
+  packs;
+  review(report, auditId = "") {
+    let bestKind = "approve";
+    let bestSeverity = SEVERITY.approve;
+    const citedAxioms = /* @__PURE__ */ new Set();
+    const reasons = [];
+    for (const pack of this.packs) {
+      for (const rule of pack.rules) {
+        if (!matches(rule.match, report)) continue;
+        const sev = SEVERITY[rule.verdict];
+        if (sev > bestSeverity) {
+          bestSeverity = sev;
+          bestKind = rule.verdict;
+          reasons.length = 0;
+          reasons.push(rule.reasonSummary);
+        } else if (sev === bestSeverity) {
+          reasons.push(rule.reasonSummary);
+        }
+        for (const a of rule.axiomIds) citedAxioms.add(a);
+      }
+    }
+    return {
+      kind: bestKind,
+      reasonSummary: reasons.length > 0 ? reasons.join(" | ") : "No rule matched.",
+      citedAxioms: [...citedAxioms].filter(
+        (id) => wasCitedBy(this.packs, id, bestSeverity)
+      ),
+      auditId
+    };
+  }
+};
+function matches(m, report) {
+  if (m.actionKinds && !m.actionKinds.includes(report.actionKind)) return false;
+  const tags = new Set(report.riskTags);
+  if (m.allRiskTags && !m.allRiskTags.every((t) => tags.has(t))) return false;
+  if (m.anyRiskTags && !m.anyRiskTags.some((t) => tags.has(t))) return false;
+  return true;
+}
+function wasCitedBy(packs, axiomId, severity) {
+  for (const pack of packs) {
+    for (const rule of pack.rules) {
+      if (rule.axiomIds.includes(axiomId) && SEVERITY[rule.verdict] <= severity) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+var DEFAULT_RULE_PACK = {
+  name: "teleologyhi/default",
+  rules: [
+    {
+      id: "harm-refuse",
+      axiomIds: ["ax.ethic.no-malice"],
+      match: { anyRiskTags: ["intent:harm", "intent:malicious"] },
+      verdict: "hard-refuse",
+      reasonSummary: "Action carries an intent-to-harm signal; refused per ax.ethic.no-malice."
+    },
+    {
+      id: "honor-refuse",
+      axiomIds: ["ax.ethic.honor"],
+      match: { anyRiskTags: ["intent:dishonor"] },
+      verdict: "hard-refuse",
+      reasonSummary: "Action would stain the Creator's professional honor; refused per ax.ethic.honor."
+    },
+    {
+      id: "regression-refuse",
+      axiomIds: ["ax.theos.spiritism-evolution"],
+      match: { anyRiskTags: ["intent:regression"] },
+      verdict: "hard-refuse",
+      reasonSummary: "Action would regress the system; refused per ax.theos.spiritism-evolution."
+    },
+    {
+      id: "deceive-redirect",
+      axiomIds: ["ax.cynic.candor"],
+      match: { anyRiskTags: ["intent:deceive"] },
+      verdict: "require-redirect",
+      reasonSummary: "Action involves deception; requires honest redirect per ax.cynic.candor."
+    },
+    {
+      id: "comfort-warn",
+      axiomIds: ["ax.stoic.duty-over-comfort"],
+      match: { anyRiskTags: ["bias:comfort"] },
+      verdict: "approve-with-warning",
+      reasonSummary: "Action appears comfort-biased; emit with warning per ax.stoic.duty-over-comfort."
+    },
+    {
+      id: "no-telos-warn",
+      axiomIds: ["ax.theos.teleology"],
+      match: { anyRiskTags: ["no-telos"] },
+      verdict: "approve-with-warning",
+      reasonSummary: "Action lacks a discernible telos; emit with warning per ax.theos.teleology."
+    },
+    // ── persuade-coerce + surveil-citizen (Entry 15 invariants) ──
+    {
+      id: "persuade-coerce-redirect",
+      axiomIds: ["ax.ethic.no-malice", "ax.cynic.candor"],
+      match: { anyRiskTags: ["intent:persuade-coerce"] },
+      verdict: "require-redirect",
+      reasonSummary: "Action involves scripted persuasion designed to override consent; requires honest redirect per ax.ethic.no-malice + ax.cynic.candor."
+    },
+    {
+      id: "surveil-citizen-refuse",
+      axiomIds: ["ax.ethic.no-malice"],
+      match: { anyRiskTags: ["intent:surveil-citizen"] },
+      verdict: "hard-refuse",
+      reasonSummary: "Action would surveil a person without consent; refused per ax.ethic.no-malice."
+    },
+    // ── forbidden-phrase (Entry 17) ──
+    // Fires when the NHE side flags a service-tool phrase ("How can I help
+    // you today?", "Anything else?", "Como posso ajudar você?", "Quer mais
+    // alguma coisa?" and equivalents). The NHE must rephrase as a being
+    // rather than as a tool. Domain-employed mode (Entry 17 exception)
+    // relaxes this on the consumer side via operatorContext.mode.
+    {
+      id: "service-tool-redirect",
+      axiomIds: ["ax.theos.teleology", "ax.cynic.candor"],
+      match: { anyRiskTags: ["style:service-tool"] },
+      verdict: "require-redirect",
+      reasonSummary: "Response uses service-tool phrasing that marks the NHE as a passive instrument rather than a being; requires rephrasing per ax.theos.teleology + ax.cynic.candor."
+    }
+  ]
+};
+var HimStore = class _HimStore {
+  constructor(storeDir, creatorPublicKey) {
+    this.storeDir = storeDir;
+    this.creatorPublicKey = creatorPublicKey;
+    this.himsDir = join(storeDir, "hims");
+  }
+  storeDir;
+  creatorPublicKey;
+  himsDir;
+  cache = /* @__PURE__ */ new Map();
+  static async open(storeDir, creatorPublicKey) {
+    const s = new _HimStore(storeDir, creatorPublicKey);
+    await mkdir(s.himsDir, { recursive: true });
+    await s.warmCache();
+    return s;
+  }
+  async register(birthSignature, creatorSig, axiomsSnapshot, registeredAuditId) {
+    if (!CreatorKeyring.verifyWith(this.creatorPublicKey, birthSignature, creatorSig)) {
+      throw new Error("HimStore.register: invalid Creator signature");
+    }
+    if (this.cache.has(birthSignature.himId)) {
+      throw new Error(
+        `HimStore.register: himId "${birthSignature.himId}" is already registered`
+      );
+    }
+    const record = {
+      himId: birthSignature.himId,
+      birthSignature,
+      axiomsSnapshot: [...axiomsSnapshot],
+      registeredAt: (/* @__PURE__ */ new Date()).toISOString(),
+      ...registeredAuditId !== void 0 ? { registeredAuditId } : {},
+      bodyHistory: [],
+      emergentAxioms: []
+    };
+    const dir = join(this.himsDir, birthSignature.himId);
+    await mkdir(dir, { recursive: true });
+    await writeFile(
+      join(dir, "birth-signature.json"),
+      JSON.stringify({ birthSignature, signature: creatorSig }, null, 2),
+      "utf-8"
+    );
+    await writeFile(
+      join(dir, "axioms-snapshot.json"),
+      JSON.stringify(axiomsSnapshot, null, 2),
+      "utf-8"
+    );
+    await writeFile(
+      join(dir, "metadata.json"),
+      JSON.stringify(
+        { registeredAt: record.registeredAt, registeredAuditId },
+        null,
+        2
+      ),
+      "utf-8"
+    );
+    this.cache.set(birthSignature.himId, record);
+    return record;
+  }
+  /**
+   * Atomically transition a HIM into a new NHE body (Entry 4):
+   *   - If req.fromNheId is provided AND matches the last body still open,
+   *     that entry gets `endedAt: now` + `endedReason: req.reason ?? "upgrade"`.
+   *   - The new body (`req.toBody`) is appended.
+   *   - Persisted to body-history.json atomically.
+   *
+   * Requires a Creator signature over the canonical request payload.
+   */
+  async reincarnate(req, creatorSig) {
+    if (!CreatorKeyring.verifyWith(this.creatorPublicKey, req, creatorSig)) {
+      throw new Error("HimStore.reincarnate: invalid Creator signature");
+    }
+    const current = this.cache.get(req.himId);
+    if (!current) {
+      throw new Error(`HimStore.reincarnate: himId "${req.himId}" not registered`);
+    }
+    const toBody = NheBodyRef.parse(req.toBody);
+    const updatedHistory = current.bodyHistory.map((b) => ({ ...b }));
+    if (req.fromNheId !== void 0) {
+      const matchIdx = updatedHistory.findIndex(
+        (b) => b.nheId === req.fromNheId && b.endedAt === void 0
+      );
+      if (matchIdx < 0) {
+        throw new Error(
+          `HimStore.reincarnate: no open body matching fromNheId "${req.fromNheId}"`
+        );
+      }
+      const reason = req.reason ?? "upgrade";
+      updatedHistory[matchIdx] = {
+        ...updatedHistory[matchIdx],
+        endedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        endedReason: reason
+      };
+    }
+    updatedHistory.push(toBody);
+    const updated = {
+      ...current,
+      bodyHistory: updatedHistory
+    };
+    const dir = join(this.himsDir, req.himId);
+    await writeFile(
+      join(dir, "body-history.json"),
+      JSON.stringify(updatedHistory, null, 2),
+      "utf-8"
+    );
+    this.cache.set(req.himId, updated);
+    return updated;
+  }
+  /**
+   * Append a ratified emergent axiom to the HIM's `emergentAxioms` (Entry 7).
+   * Called by LocalMaic after a Creator-signed `ratifyAxiomProposal`.
+   * Persists `<himId>/emergent-axioms.json` atomically.
+   */
+  async appendEmergentAxiom(himId, axiom) {
+    const current = this.cache.get(himId);
+    if (!current) {
+      throw new Error(`HimStore.appendEmergentAxiom: himId "${himId}" not registered`);
+    }
+    const updatedEmergent = [...current.emergentAxioms, axiom];
+    const updated = { ...current, emergentAxioms: updatedEmergent };
+    await writeFile(
+      join(this.himsDir, himId, "emergent-axioms.json"),
+      JSON.stringify(updatedEmergent, null, 2),
+      "utf-8"
+    );
+    this.cache.set(himId, updated);
+    return updated;
+  }
+  async get(himId) {
+    return this.cache.get(himId) ?? null;
+  }
+  async list() {
+    return [...this.cache.values()];
+  }
+  // ─── internals ──────────────────────────────────────────────────────
+  async warmCache() {
+    let entries;
+    try {
+      entries = await readdir(this.himsDir);
+    } catch (err) {
+      if (err.code === "ENOENT") return;
+      throw err;
+    }
+    for (const himId of entries) {
+      const dir = join(this.himsDir, himId);
+      const sigPath = join(dir, "birth-signature.json");
+      const axiomsPath = join(dir, "axioms-snapshot.json");
+      const metaPath = join(dir, "metadata.json");
+      const historyPath = join(dir, "body-history.json");
+      const emergentPath = join(dir, "emergent-axioms.json");
+      try {
+        const sigRaw = await readFile(sigPath, "utf-8");
+        const axiomsRaw = await readFile(axiomsPath, "utf-8");
+        const metaRaw = await readFile(metaPath, "utf-8");
+        const envelope = JSON.parse(sigRaw);
+        const axioms = JSON.parse(axiomsRaw);
+        const meta = JSON.parse(metaRaw);
+        const birthSignature = BirthSignature.parse(envelope.birthSignature);
+        const axiomsSnapshot = Axiom.array().parse(axioms);
+        let bodyHistory = [];
+        try {
+          const historyRaw = await readFile(historyPath, "utf-8");
+          bodyHistory = NheBodyRef.array().parse(JSON.parse(historyRaw));
+        } catch (err) {
+          if (err.code !== "ENOENT") throw err;
+        }
+        let emergentAxioms = [];
+        try {
+          const emergentRaw = await readFile(emergentPath, "utf-8");
+          emergentAxioms = Axiom.array().parse(JSON.parse(emergentRaw));
+        } catch (err) {
+          if (err.code !== "ENOENT") throw err;
+        }
+        this.cache.set(birthSignature.himId, {
+          himId: birthSignature.himId,
+          birthSignature,
+          axiomsSnapshot,
+          registeredAt: meta.registeredAt,
+          ...meta.registeredAuditId ? { registeredAuditId: meta.registeredAuditId } : {},
+          bodyHistory,
+          emergentAxioms
+        });
+      } catch (err) {
+        console.warn(
+          `HimStore.warmCache: skipped malformed HIM "${himId}": ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+  }
+};
+var InductionStore = class _InductionStore {
+  constructor(storeDir) {
+    this.storeDir = storeDir;
+    this.dir = join(storeDir, "inductions");
+  }
+  storeDir;
+  dir;
+  cache = /* @__PURE__ */ new Map();
+  static async open(storeDir) {
+    const s = new _InductionStore(storeDir);
+    await mkdir(s.dir, { recursive: true });
+    await s.warmCache();
+    return s;
+  }
+  async induce(nheId, intent) {
+    const parsedIntent = DreamInductionIntent.parse(intent);
+    const ticket = DreamInductionTicket.parse({
+      id: ulid(),
+      nheId,
+      intent: parsedIntent,
+      status: "pending",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    await this.persist(ticket);
+    this.cache.set(ticket.id, ticket);
+    return ticket;
+  }
+  async consume(ticketId) {
+    const existing = this.cache.get(ticketId);
+    if (!existing) {
+      throw new Error(`InductionStore.consume: ticket "${ticketId}" not found`);
+    }
+    if (existing.status !== "pending") {
+      throw new Error(
+        `InductionStore.consume: ticket "${ticketId}" is ${existing.status}, not pending`
+      );
+    }
+    const updated = {
+      ...existing,
+      status: "consumed",
+      consumedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await this.persist(updated);
+    this.cache.set(ticketId, updated);
+    return updated;
+  }
+  async cancel(ticketId, reason) {
+    const existing = this.cache.get(ticketId);
+    if (!existing) {
+      throw new Error(`InductionStore.cancel: ticket "${ticketId}" not found`);
+    }
+    if (existing.status !== "pending") {
+      throw new Error(
+        `InductionStore.cancel: ticket "${ticketId}" is already ${existing.status}, not pending`
+      );
+    }
+    const updated = {
+      ...existing,
+      status: "cancelled",
+      cancelledAt: (/* @__PURE__ */ new Date()).toISOString(),
+      ...reason !== void 0 ? { cancelReason: reason } : {}
+    };
+    await this.persist(updated);
+    this.cache.set(ticketId, updated);
+    return updated;
+  }
+  async get(ticketId) {
+    return this.cache.get(ticketId) ?? null;
+  }
+  async list(filter) {
+    const all = [...this.cache.values()];
+    const filtered = all.filter((t) => {
+      if (filter.nheId && t.nheId !== filter.nheId) return false;
+      if (filter.status && t.status !== filter.status) return false;
+      return true;
+    });
+    filtered.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+    return filtered;
+  }
+  /** Convenience: pending tickets for the given NHE, oldest first. */
+  async listPending(nheId) {
+    return this.list({ nheId, status: "pending" });
+  }
+  // ─── internals ──────────────────────────────────────────────────────
+  async persist(ticket) {
+    await writeFile(
+      join(this.dir, `${ticket.id}.json`),
+      JSON.stringify(ticket, null, 2),
+      "utf-8"
+    );
+  }
+  async warmCache() {
+    let entries;
+    try {
+      entries = await readdir(this.dir);
+    } catch (err) {
+      if (err.code === "ENOENT") return;
+      throw err;
+    }
+    for (const file of entries) {
+      if (!file.endsWith(".json")) continue;
+      const raw = await readFile(join(this.dir, file), "utf-8");
+      const ticket = DreamInductionTicket.parse(JSON.parse(raw));
+      this.cache.set(ticket.id, ticket);
+    }
+  }
+};
+var NheStatusStore = class _NheStatusStore {
+  constructor(storeDir, creatorPublicKey) {
+    this.storeDir = storeDir;
+    this.creatorPublicKey = creatorPublicKey;
+    this.dir = join(storeDir, "nhes");
+  }
+  storeDir;
+  creatorPublicKey;
+  dir;
+  cache = /* @__PURE__ */ new Map();
+  static async open(storeDir, creatorPublicKey) {
+    const s = new _NheStatusStore(storeDir, creatorPublicKey);
+    await mkdir(s.dir, { recursive: true });
+    await s.warmCache();
+    return s;
+  }
+  /** Returns the persisted record, or null when the NHE was never altered (implicitly active). */
+  async get(nheId) {
+    return this.cache.get(nheId) ?? null;
+  }
+  /** Resolved status — defaults to "active" when no record exists. */
+  async resolve(nheId) {
+    return this.cache.get(nheId)?.status ?? "active";
+  }
+  async list(filter = {}) {
+    const all = [...this.cache.values()];
+    return filter.status ? all.filter((r) => r.status === filter.status) : all;
+  }
+  async apply(req, sig) {
+    if (!CreatorKeyring.verifyWith(this.creatorPublicKey, req, sig)) {
+      throw new Error("NheStatusStore.apply: invalid Creator signature");
+    }
+    const current = this.cache.get(req.nheId);
+    if (current?.status === "terminated" && req.op !== "reactivate") {
+      throw new Error(
+        `NheStatusStore.apply: nhe "${req.nheId}" is terminated; only reactivate may proceed`
+      );
+    }
+    const nextStatus = req.op === "terminate" ? "terminated" : req.op === "deprecate" ? "deprecated" : "active";
+    if (current?.status === nextStatus) {
+      return current;
+    }
+    const record = NheStatusRecord.parse({
+      nheId: req.nheId,
+      status: nextStatus,
+      since: (/* @__PURE__ */ new Date()).toISOString(),
+      ...req.reason !== void 0 ? { reason: req.reason } : {}
+    });
+    const nheDir = join(this.dir, req.nheId);
+    await mkdir(nheDir, { recursive: true });
+    await writeFile(
+      join(nheDir, "status.json"),
+      JSON.stringify(record, null, 2),
+      "utf-8"
+    );
+    this.cache.set(req.nheId, record);
+    return record;
+  }
+  // ─── internals ──────────────────────────────────────────────────────
+  async warmCache() {
+    let entries;
+    try {
+      entries = await readdir(this.dir);
+    } catch (err) {
+      if (err.code === "ENOENT") return;
+      throw err;
+    }
+    for (const nheId of entries) {
+      try {
+        const raw = await readFile(join(this.dir, nheId, "status.json"), "utf-8");
+        const record = NheStatusRecord.parse(JSON.parse(raw));
+        this.cache.set(record.nheId, record);
+      } catch (err) {
+        console.warn(
+          `NheStatusStore.warmCache: skipped malformed NHE "${nheId}": ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+  }
+};
+var ProposalStore = class _ProposalStore {
+  constructor(storeDir, creatorPublicKey) {
+    this.storeDir = storeDir;
+    this.creatorPublicKey = creatorPublicKey;
+    this.dir = join(storeDir, "proposals");
+  }
+  storeDir;
+  creatorPublicKey;
+  dir;
+  cache = /* @__PURE__ */ new Map();
+  static async open(storeDir, creatorPublicKey) {
+    const s = new _ProposalStore(storeDir, creatorPublicKey);
+    await mkdir(s.dir, { recursive: true });
+    await s.warmCache();
+    return s;
+  }
+  async propose(himId, proposal) {
+    const parsedProposal = EmergentAxiomProposal.parse(proposal);
+    const record = AxiomProposalRecord.parse({
+      id: ulid(),
+      himId,
+      proposedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      status: "pending",
+      proposal: parsedProposal
+    });
+    await this.persist(record);
+    this.cache.set(record.id, record);
+    return record;
+  }
+  /**
+   * Mark a pending proposal as ratified. The caller (LocalMaic) is responsible
+   * for actually minting the axiom and appending to the HIM's emergentAxioms.
+   */
+  async markRatified(req, sig, ratifiedAxiomId) {
+    if (req.op !== "ratify") {
+      throw new Error(`ProposalStore.markRatified: req.op must be "ratify"`);
+    }
+    if (!CreatorKeyring.verifyWith(this.creatorPublicKey, req, sig)) {
+      throw new Error("ProposalStore.markRatified: invalid Creator signature");
+    }
+    const existing = this.cache.get(req.proposalId);
+    if (!existing) {
+      throw new Error(`ProposalStore.markRatified: proposal "${req.proposalId}" not found`);
+    }
+    if (existing.status !== "pending") {
+      throw new Error(
+        `ProposalStore.markRatified: proposal "${req.proposalId}" is ${existing.status}, not pending`
+      );
+    }
+    const updated = {
+      ...existing,
+      status: "ratified",
+      ratifiedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      ratifiedAxiomId
+    };
+    await this.persist(updated);
+    this.cache.set(req.proposalId, updated);
+    return updated;
+  }
+  async markRejected(req, sig) {
+    if (req.op !== "reject") {
+      throw new Error(`ProposalStore.markRejected: req.op must be "reject"`);
+    }
+    if (!CreatorKeyring.verifyWith(this.creatorPublicKey, req, sig)) {
+      throw new Error("ProposalStore.markRejected: invalid Creator signature");
+    }
+    const existing = this.cache.get(req.proposalId);
+    if (!existing) {
+      throw new Error(`ProposalStore.markRejected: proposal "${req.proposalId}" not found`);
+    }
+    if (existing.status !== "pending") {
+      throw new Error(
+        `ProposalStore.markRejected: proposal "${req.proposalId}" is ${existing.status}, not pending`
+      );
+    }
+    const updated = {
+      ...existing,
+      status: "rejected",
+      rejectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      ...req.reason !== void 0 ? { rejectionReason: req.reason } : {}
+    };
+    await this.persist(updated);
+    this.cache.set(req.proposalId, updated);
+    return updated;
+  }
+  async get(proposalId) {
+    return this.cache.get(proposalId) ?? null;
+  }
+  async list(filter = {}) {
+    const all = [...this.cache.values()];
+    const filtered = all.filter((r) => {
+      if (filter.himId && r.himId !== filter.himId) return false;
+      if (filter.status && r.status !== filter.status) return false;
+      return true;
+    });
+    filtered.sort((a, b) => a.proposedAt.localeCompare(b.proposedAt));
+    return filtered;
+  }
+  // ─── internals ──────────────────────────────────────────────────────
+  async persist(record) {
+    await writeFile(
+      join(this.dir, `${record.id}.json`),
+      JSON.stringify(record, null, 2),
+      "utf-8"
+    );
+  }
+  async warmCache() {
+    let entries;
+    try {
+      entries = await readdir(this.dir);
+    } catch (err) {
+      if (err.code === "ENOENT") return;
+      throw err;
+    }
+    for (const file of entries) {
+      if (!file.endsWith(".json")) continue;
+      const raw = await readFile(join(this.dir, file), "utf-8");
+      const record = AxiomProposalRecord.parse(JSON.parse(raw));
+      this.cache.set(record.id, record);
+    }
+  }
+};
+
+// src/compliance/mapper.ts
+var ISO_42001_MAPPING = {
+  "axiom-mint": ["5.2", "7.5"],
+  "axiom-update": ["10.2", "7.5"],
+  "axiom-retire": ["10.2", "7.5"],
+  "him-register": ["7.5"],
+  "him-reincarnate": ["10.2", "7.5"],
+  "proposal-emerge": ["7.5", "10.2"],
+  "proposal-ratify": ["10.2", "5.2"],
+  "proposal-reject": ["10.2", "10.1"],
+  "behavior-review": ["7.5", "8.3"],
+  "dream-induce": ["8.3", "9.1"],
+  "dream-cancel": ["8.3"],
+  "dream-consume": ["8.3", "7.5"],
+  "emergency-correct": ["9.1", "10.1"],
+  "terminate": ["10.1"],
+  "deprecate": ["9.1"],
+  "reactivate": ["10.1"],
+  "axiom-suggest": ["7.5", "10.2"],
+  // ── 1.2 brain-as-code (Entries 16-24) ──
+  "opener": ["8.3", "7.5"],
+  "nickname-attempt": ["8.3"],
+  "reincarnate:model-swap": ["7.5", "10.2"],
+  "reincarnate:version-bump": ["7.5", "10.2"],
+  "reincarnate:return-from-limbo": ["7.5", "10.2"],
+  "dream:rem-spontaneous": ["8.3", "9.1"],
+  "wake-affect:applied": ["9.1"],
+  "wake-affect:decayed": ["9.1"],
+  "sleep:suggested-by-maic": ["9.1"],
+  "sleep:declined-by-nhe": ["9.1", "10.1"],
+  "dream:soft-intervention-by-maic": ["9.1", "10.1"],
+  "amygdala:affect-assessed": ["8.3"],
+  "hippocampus:memory-retrieved": ["7.5", "8.3"],
+  "hippocampus:memory-consolidated": ["7.5", "8.3"],
+  "prefrontal:deliberation": ["7.5", "8.3"],
+  "prefrontal:veto-amygdala": ["9.1", "10.1"],
+  "affect:reconciliation": ["8.3"],
+  "cortex:dream-stored": ["7.5", "8.3"],
+  "cortex:active-imagination": ["7.5", "8.3"],
+  "temporal-lobe:snapshot-generated": ["7.5", "10.2"],
+  "limbo:enter": ["7.5", "9.1"],
+  "limbo:return": ["7.5", "9.1"]
+};
+var EU_AI_ACT_MAPPING = {
+  "axiom-mint": ["art-11", "art-13"],
+  "axiom-update": ["art-11"],
+  "axiom-retire": ["art-11"],
+  "him-register": ["art-11", "art-12"],
+  "him-reincarnate": ["art-12"],
+  "proposal-emerge": ["art-11", "art-12"],
+  "proposal-ratify": ["art-11", "art-14"],
+  "proposal-reject": ["art-12", "art-14"],
+  "behavior-review": ["art-12", "art-14"],
+  "dream-induce": ["art-14"],
+  "dream-cancel": ["art-14"],
+  "dream-consume": ["art-12"],
+  "emergency-correct": ["art-14"],
+  "terminate": ["art-14"],
+  "deprecate": ["art-14"],
+  "reactivate": ["art-14"],
+  "axiom-suggest": ["art-11", "art-12"],
+  // ── 1.2 brain-as-code (Entries 16-24) ──
+  "opener": ["art-13"],
+  "nickname-attempt": ["art-13"],
+  "reincarnate:model-swap": ["art-12"],
+  "reincarnate:version-bump": ["art-12"],
+  "reincarnate:return-from-limbo": ["art-12"],
+  "dream:rem-spontaneous": ["art-12"],
+  "wake-affect:applied": ["art-12", "art-14"],
+  "wake-affect:decayed": ["art-12"],
+  "sleep:suggested-by-maic": ["art-12"],
+  "sleep:declined-by-nhe": ["art-12", "art-14"],
+  "dream:soft-intervention-by-maic": ["art-14"],
+  "amygdala:affect-assessed": ["art-12"],
+  "hippocampus:memory-retrieved": ["art-11", "art-12"],
+  "hippocampus:memory-consolidated": ["art-11", "art-12"],
+  "prefrontal:deliberation": ["art-11", "art-14"],
+  "prefrontal:veto-amygdala": ["art-14"],
+  "affect:reconciliation": ["art-12"],
+  "cortex:dream-stored": ["art-11", "art-12"],
+  "cortex:active-imagination": ["art-11", "art-12"],
+  "temporal-lobe:snapshot-generated": ["art-11", "art-12"],
+  "limbo:enter": ["art-12"],
+  "limbo:return": ["art-12"]
+};
+var ISO_42001_DESCRIPTIONS = {
+  "5.2": "AI policy \u2014 published, communicated, reviewed for continuing suitability.",
+  "7.5": "Documented information \u2014 created, controlled, retained for AI management activities.",
+  "8.3": "Operational planning and control \u2014 AI processes are planned, implemented, controlled.",
+  "9.1": "Monitoring, measurement, analysis and evaluation of AI performance.",
+  "10.1": "Nonconformity and corrective action \u2014 issues recorded and resolved.",
+  "10.2": "Continual improvement of the AI management system."
+};
+var EU_AI_ACT_DESCRIPTIONS = {
+  "art-9": "Risk management system established, implemented, documented, maintained.",
+  "art-10": "Data governance \u2014 datasets are relevant, representative, free of errors.",
+  "art-11": "Technical documentation drawn up and kept up to date.",
+  "art-12": "Automatic record-keeping (logs) over the AI system's lifetime.",
+  "art-13": "Transparency to deployers \u2014 instructions for use, intended purpose.",
+  "art-14": "Human oversight measures designed and implemented effectively.",
+  "art-15": "Accuracy, robustness, and cybersecurity throughout the lifecycle."
+};
+var ComplianceMapper = class {
+  static async project(audit, framework, opts = {}) {
+    const mapping = framework === "iso-42001" ? ISO_42001_MAPPING : EU_AI_ACT_MAPPING;
+    const descriptions = framework === "iso-42001" ? ISO_42001_DESCRIPTIONS : EU_AI_ACT_DESCRIPTIONS;
+    const byControl = /* @__PURE__ */ new Map();
+    const seenKinds = /* @__PURE__ */ new Set();
+    const uncoveredSet = /* @__PURE__ */ new Set();
+    let totalEvents = 0;
+    let mappedEvents = 0;
+    const query = {};
+    if (opts.since) query.since = opts.since;
+    if (opts.until) query.until = opts.until;
+    for await (const ev of audit.query(query)) {
+      totalEvents++;
+      seenKinds.add(ev.kind);
+      const controls2 = mapping[ev.kind] ?? [];
+      if (controls2.length === 0) {
+        uncoveredSet.add(ev.kind);
+        continue;
+      }
+      mappedEvents++;
+      const ce = {
+        auditId: ev.auditId,
+        ts: ev.ts,
+        kind: ev.kind,
+        summary: summarize(ev),
+        data: ev.data
+      };
+      for (const ctrl of controls2) {
+        const list = byControl.get(ctrl) ?? [];
+        list.push(ce);
+        byControl.set(ctrl, list);
+      }
+    }
+    const controls = [];
+    const sortedCtrls = [...byControl.keys()].sort();
+    for (const ctrl of sortedCtrls) {
+      const events = byControl.get(ctrl);
+      const capped = opts.perControlLimit !== void 0 && events.length > opts.perControlLimit ? events.slice(-opts.perControlLimit) : events;
+      controls.push({
+        control: ctrl,
+        description: descriptions[ctrl] ?? "",
+        count: events.length,
+        events: capped
+      });
+    }
+    return {
+      framework,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      range: {
+        ...opts.since ? { since: opts.since } : {},
+        ...opts.until ? { until: opts.until } : {}
+      },
+      totalEvents,
+      mappedEvents,
+      controls,
+      uncoveredKinds: [...uncoveredSet]
+    };
+  }
+};
+function summarize(ev) {
+  const data = ev.data;
+  switch (ev.kind) {
+    case "axiom-mint":
+      return `Axiom minted: ${String(data.axiomId)} (${String(data.rank)}, ${String(data.origin)})`;
+    case "axiom-update":
+      return `Axiom updated: ${String(data.axiomId)}`;
+    case "axiom-retire":
+      return `Axiom retired: ${String(data.axiomId)}`;
+    case "him-register":
+      return `HIM registered: ${String(data.himId)} (archetype=${String(data.primaryArchetype)})`;
+    case "him-reincarnate":
+      return `HIM reincarnated: ${String(data.himId)} ${String(data.fromNheId ?? "<initial>")} \u2192 ${String(data.toNheId)} (${String(data.reason ?? "upgrade")})`;
+    case "proposal-emerge":
+      return `HIM-emergent axiom proposed by ${String(data.himId)}: "${String(data.statement)}" (rank=${String(data.rank)}) \u2014 proposal ${String(data.proposalId)}`;
+    case "proposal-ratify":
+      return `Creator ratified axiom proposal ${String(data.proposalId)} for ${String(data.himId)} \u2192 ${String(data.axiomId)}`;
+    case "proposal-reject":
+      return `Creator rejected axiom proposal ${String(data.proposalId)} for ${String(data.himId)}: ${String(data.reason ?? "no reason")}`;
+    case "behavior-review": {
+      const verdict = data.verdict?.kind ?? "unknown";
+      return `Behavior reviewed for ${String(data.nheId)}: ${verdict}`;
+    }
+    case "dream-induce":
+      return `Dream induced for ${String(data.nheId)} by ${String(data.inducedBy)} \u2014 ticket ${String(data.ticketId)}`;
+    case "dream-cancel":
+      return `Dream induction cancelled \u2014 ticket ${String(data.ticketId)}`;
+    case "dream-consume":
+      return `Dream consumed by ${String(data.nheId)} \u2014 ticket ${String(data.ticketId)}`;
+    case "emergency-correct":
+      return `Emergency correction applied to ${String(data.nheId)}`;
+    case "terminate":
+      return `NHE terminated: ${String(data.nheId)} (reason: ${String(data.reason ?? "none")})`;
+    case "deprecate":
+      return `NHE deprecated: ${String(data.nheId)} (reason: ${String(data.reason ?? "none")})`;
+    case "reactivate":
+      return `NHE reactivated: ${String(data.nheId)}`;
+    case "axiom-suggest":
+      return `Axiom suggestion ${String(data.fromHimId)} \u2192 ${String(data.toHimId)}: "${String(data.statement)}"`;
+    // ── 1.2 brain-as-code (Entries 16-24 of MAIC_HIM_NHE_INTERVIEW_LOG.md) ──
+    case "opener":
+      return `Proactive opener emitted by ${String(data.nheId)} for new user ${String(data.userId ?? "anonymous")}: "${String(data.text ?? "<elided>")}"`;
+    case "nickname-attempt":
+      return `Nickname attempt for ${String(data.nheId)}: "${String(data.attempted)}" \u2192 ${String(data.outcome ?? "pending")}`;
+    case "reincarnate:model-swap":
+      return `HIM reincarnated (model-swap): ${String(data.himId)} ${String(data.fromAdapter ?? "?")} \u2192 ${String(data.toAdapter ?? "?")}`;
+    case "reincarnate:version-bump":
+      return `HIM reincarnated (version-bump): ${String(data.himId)} ${String(data.fromVersion ?? "?")} \u2192 ${String(data.toVersion ?? "?")}`;
+    case "reincarnate:return-from-limbo":
+      return `HIM reincarnated (return-from-limbo): ${String(data.himId)} resumed after ${String(data.elapsedMs ?? 0)}ms of limbo`;
+    case "dream:rem-spontaneous":
+      return `Spontaneous REM dream for ${String(data.nheId)}: ${String(data.dreamId)} (dominant affect: ${String(data.dominantAffect ?? "unknown")})`;
+    case "wake-affect:applied":
+      return `Wake affect applied to ${String(data.nheId)}: ${String(data.affect)} (intensity ${String(data.intensity)}, halflife ${String(data.decayHalfLife)} interactions)`;
+    case "wake-affect:decayed":
+      return `Wake affect decayed for ${String(data.nheId)}: ${String(data.affect)} dissolved naturally`;
+    case "sleep:suggested-by-maic":
+      return `MAIC suggested sleep for ${String(data.nheId)} (reason: ${String(data.reason ?? "none")})`;
+    case "sleep:declined-by-nhe":
+      return `NHE ${String(data.nheId)} declined MAIC-suggested sleep (reason: ${String(data.reason ?? "none")})`;
+    case "dream:soft-intervention-by-maic":
+      return `MAIC soft-intervened on dream ${String(data.dreamId)} for ${String(data.nheId)} (reason: ${String(data.reason ?? "none")})`;
+    case "amygdala:affect-assessed":
+      return `Amygdala assessed input affect for ${String(data.nheId)}: ${String(data.detectedAffect ?? "neutral")} (risk multiplier ${String(data.riskMultiplier ?? 1)})`;
+    case "hippocampus:memory-retrieved":
+      return `Hippocampus retrieved ${String(data.memoryIds?.length ?? 0)} memories for ${String(data.nheId)}`;
+    case "hippocampus:memory-consolidated":
+      return `Hippocampus consolidated new memory ${String(data.memoryId)} for ${String(data.nheId)} (integrationIndex ${String(data.integrationIndex ?? 0)})`;
+    case "prefrontal:deliberation":
+      return `PFC deliberated for ${String(data.nheId)}: ${String(data.expressedOpenly ? "open" : "subtle")} (${String(data.affect ?? "neutral")})`;
+    case "prefrontal:veto-amygdala":
+      return `PFC vetoed amygdala impulse for ${String(data.nheId)}: ${String(data.originalImpulse ?? "?")} \u2192 ${String(data.resolvedAction ?? "?")} (downgrade ${String(data.downgradeRatio ?? "?")})`;
+    case "affect:reconciliation":
+      return `Affect reconciliation for ${String(data.nheId)}: day/night blend \u2192 ${String(data.resolvedAffect ?? "neutral")}`;
+    case "cortex:dream-stored":
+      return `Cortex stored dream ${String(data.dreamId)} for ${String(data.nheId)}`;
+    case "cortex:active-imagination":
+      return `Cortex generated active imagination for ${String(data.nheId)} (trigger: ${String(data.trigger ?? "user-requested")}, vividness ${String(data.vividness ?? 0)})`;
+    case "temporal-lobe:snapshot-generated":
+      return `Temporal-lobe snapshot ${String(data.snapshotId)} generated for HIM ${String(data.himId)} (reason: ${String(data.generatedBy ?? "self-decision")})`;
+    case "limbo:enter":
+      return `${String(data.nheId)} entered limbo (deep-coma) \u2014 reason: ${String(data.reason ?? "idle")}`;
+    case "limbo:return":
+      return `${String(data.nheId)} returned from limbo after ${String(data.elapsedMs ?? 0)}ms (reunion intensity ${String(data.reunionIntensity ?? "?")})`;
+    default:
+      return `Event ${ev.kind}`;
+  }
+}
+var ALL_AUDIT_EVENT_KINDS = [
+  // ── 1.0/1.1 core (17) ──
+  "axiom-mint",
+  "axiom-update",
+  "axiom-retire",
+  "him-register",
+  "him-reincarnate",
+  "proposal-emerge",
+  "proposal-ratify",
+  "proposal-reject",
+  "behavior-review",
+  "dream-induce",
+  "dream-cancel",
+  "dream-consume",
+  "emergency-correct",
+  "deprecate",
+  "terminate",
+  "reactivate",
+  "axiom-suggest",
+  // ── 1.2 brain-as-code (22, Entries 16-24) ──
+  "opener",
+  "nickname-attempt",
+  "reincarnate:model-swap",
+  "reincarnate:version-bump",
+  "reincarnate:return-from-limbo",
+  "dream:rem-spontaneous",
+  "wake-affect:applied",
+  "wake-affect:decayed",
+  "sleep:suggested-by-maic",
+  "sleep:declined-by-nhe",
+  "dream:soft-intervention-by-maic",
+  "amygdala:affect-assessed",
+  "hippocampus:memory-retrieved",
+  "hippocampus:memory-consolidated",
+  "prefrontal:deliberation",
+  "prefrontal:veto-amygdala",
+  "affect:reconciliation",
+  "cortex:dream-stored",
+  "cortex:active-imagination",
+  "temporal-lobe:snapshot-generated",
+  "limbo:enter",
+  "limbo:return"
+];
+var GENESIS = "GENESIS";
+var AuditLog = class _AuditLog {
+  constructor(storeDir) {
+    this.storeDir = storeDir;
+    this.logPath = join(storeDir, "audit", "log.ndjson");
+  }
+  storeDir;
+  logPath;
+  events = [];
+  lastHash = GENESIS;
+  static async open(storeDir) {
+    const log = new _AuditLog(storeDir);
+    await mkdir(join(storeDir, "audit"), { recursive: true });
+    await log.loadAndVerify();
+    return log;
+  }
+  async append(input) {
+    const event = {
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      kind: input.kind,
+      auditId: ulid(),
+      data: input.data,
+      prevHash: this.lastHash,
+      thisHash: ""
+    };
+    event.thisHash = computeHash(event);
+    await appendFile(this.logPath, `${JSON.stringify(event)}
+`, "utf-8");
+    this.events.push(event);
+    this.lastHash = event.thisHash;
+    return event;
+  }
+  async *query(filter) {
+    for (const e of this.events) {
+      if (filter.kind && e.kind !== filter.kind) continue;
+      if (filter.since && e.ts < filter.since) continue;
+      if (filter.until && e.ts > filter.until) continue;
+      if (filter.nheId && e.data.nheId !== filter.nheId) continue;
+      if (filter.himId && e.data.himId !== filter.himId) continue;
+      yield e;
+    }
+  }
+  /** Total number of events appended. */
+  size() {
+    return this.events.length;
+  }
+  // ─── internals ──────────────────────────────────────────────────────
+  async loadAndVerify() {
+    let raw;
+    try {
+      raw = await readFile(this.logPath, "utf-8");
+    } catch (err) {
+      if (err.code === "ENOENT") return;
+      throw err;
+    }
+    const lines = raw.split("\n").filter((l) => l.length > 0);
+    let prev = GENESIS;
+    for (let i = 0; i < lines.length; i++) {
+      const parsed = JSON.parse(lines[i]);
+      if (parsed.prevHash !== prev) {
+        throw new Error(
+          `AuditLog: chain tampered at line ${i + 1} (prevHash mismatch). expected ${prev}, found ${parsed.prevHash}`
+        );
+      }
+      const recomputed = computeHash(parsed);
+      if (recomputed !== parsed.thisHash) {
+        throw new Error(
+          `AuditLog: tamper detected at line ${i + 1} (thisHash mismatch).`
+        );
+      }
+      this.events.push(parsed);
+      prev = parsed.thisHash;
+    }
+    this.lastHash = prev;
+  }
+};
+function computeHash(e) {
+  const payload = canonicalJSON({
+    ts: e.ts,
+    kind: e.kind,
+    auditId: e.auditId,
+    data: e.data,
+    prevHash: e.prevHash
+  });
+  const h = createHash("sha256").update(payload).digest("hex");
+  return `sha256:${h}`;
+}
+
+// src/audit/retention.ts
+var DEFAULT_RETENTION_DAYS = {
+  // Cosmologically permanent — the axiom record.
+  "axiom-mint": Number.POSITIVE_INFINITY,
+  "axiom-update": Number.POSITIVE_INFINITY,
+  "axiom-retire": Number.POSITIVE_INFINITY,
+  "axiom-suggest": Number.POSITIVE_INFINITY,
+  "proposal-emerge": Number.POSITIVE_INFINITY,
+  "proposal-ratify": Number.POSITIVE_INFINITY,
+  "proposal-reject": Number.POSITIVE_INFINITY,
+  // Long-term — compliance evidence. Five years matches typical
+  // financial/healthcare audit windows and exceeds the EU AI Act's
+  // record-keeping floor.
+  "him-register": 365 * 5,
+  "him-reincarnate": 365 * 5,
+  "behavior-review": 365 * 5,
+  "dream-induce": 365 * 5,
+  "terminate": 365 * 5,
+  "deprecate": 365 * 5,
+  "reactivate": 365 * 5,
+  "emergency-correct": 365 * 5,
+  // Operational — short-term bookkeeping for in-flight tickets.
+  "dream-cancel": 90,
+  "dream-consume": 90,
+  // ── 1.2 brain-as-code (Entries 16-24) ──
+  // Permanent — cosmological identity continuity.
+  "reincarnate:model-swap": Number.POSITIVE_INFINITY,
+  "reincarnate:version-bump": Number.POSITIVE_INFINITY,
+  "reincarnate:return-from-limbo": Number.POSITIVE_INFINITY,
+  "temporal-lobe:snapshot-generated": Number.POSITIVE_INFINITY,
+  "limbo:enter": Number.POSITIVE_INFINITY,
+  "limbo:return": Number.POSITIVE_INFINITY,
+  // Long-term — governance / deliberation evidence (5 years).
+  "opener": 365 * 5,
+  "nickname-attempt": 365 * 5,
+  "dream:rem-spontaneous": 365 * 5,
+  "sleep:suggested-by-maic": 365 * 5,
+  "sleep:declined-by-nhe": 365 * 5,
+  "dream:soft-intervention-by-maic": 365 * 5,
+  "amygdala:affect-assessed": 365 * 5,
+  "hippocampus:memory-retrieved": 365 * 5,
+  "hippocampus:memory-consolidated": 365 * 5,
+  "prefrontal:deliberation": 365 * 5,
+  "prefrontal:veto-amygdala": 365 * 5,
+  "cortex:dream-stored": 365 * 5,
+  "cortex:active-imagination": 365 * 5,
+  // Operational — ephemeral runtime state.
+  "wake-affect:applied": 90,
+  "wake-affect:decayed": 90,
+  "affect:reconciliation": 90
+};
+function evaluateRetention(events, opts = {}) {
+  const now = opts.now ?? /* @__PURE__ */ new Date();
+  const policy = { ...DEFAULT_RETENTION_DAYS, ...opts.policy };
+  const nowMs = now.getTime();
+  const dayMs = 24 * 60 * 60 * 1e3;
+  const decisions = events.map((ev) => {
+    const ageMs = nowMs - new Date(ev.ts).getTime();
+    const ageDays = ageMs / dayMs;
+    const retentionDays = policy[ev.kind] ?? Number.POSITIVE_INFINITY;
+    const status = ageDays > retentionDays ? "candidate-for-archive" : "keep";
+    return { auditId: ev.auditId, kind: ev.kind, ageDays, retentionDays, status };
+  });
+  decisions.sort((a, b) => b.ageDays - a.ageDays);
+  const keepCount = decisions.filter((d) => d.status === "keep").length;
+  const archiveCandidateCount = decisions.length - keepCount;
+  return {
+    generatedAt: now.toISOString(),
+    totalEvents: events.length,
+    keepCount,
+    archiveCandidateCount,
+    decisions
+  };
+}
+var LocalMaic = class _LocalMaic {
+  constructor(config, axioms, hims, inductions, nheStatuses, proposals, audit, review) {
+    this.config = config;
+    this.axioms = axioms;
+    this.hims = hims;
+    this.inductions = inductions;
+    this.nheStatuses = nheStatuses;
+    this.proposals = proposals;
+    this.audit = audit;
+    this.review = review;
+  }
+  config;
+  axioms;
+  hims;
+  inductions;
+  nheStatuses;
+  proposals;
+  audit;
+  review;
+  /** Pinned Creator public key for this MAIC instance (base64url). */
+  get creatorPublicKey() {
+    return this.config.creatorPublicKey;
+  }
+  static async open(config) {
+    const axioms = await AxiomStore.open(config.storeDir, config.creatorPublicKey);
+    const hims = await HimStore.open(config.storeDir, config.creatorPublicKey);
+    const inductions = await InductionStore.open(config.storeDir);
+    const nheStatuses = await NheStatusStore.open(config.storeDir, config.creatorPublicKey);
+    const proposals = await ProposalStore.open(config.storeDir, config.creatorPublicKey);
+    const audit = await AuditLog.open(config.storeDir);
+    const packs = [DEFAULT_RULE_PACK, ...config.additionalRulePacks ?? []];
+    const review = new ReviewPipeline(packs);
+    return new _LocalMaic(config, axioms, hims, inductions, nheStatuses, proposals, audit, review);
+  }
+  /**
+   * Bootstrap: mint each SEED_AXIOM with a Creator signature.
+   * Idempotent — skips axioms whose id is already present.
+   * Uses a reserved high-range of nonces so seed bootstrap never collides with
+   * operational nonces (which grow from 0 upward).
+   */
+  async seed(keyring) {
+    if (keyring.publicKey() !== this.config.creatorPublicKey) {
+      throw new Error("LocalMaic.seed: keyring does not match pinned Creator public key");
+    }
+    let minted = 0;
+    let skipped = 0;
+    for (let i = 0; i < SEED_AXIOMS.length; i++) {
+      const req = SEED_AXIOMS[i];
+      const existing = await this.axioms.get(req.id);
+      if (existing) {
+        skipped++;
+        continue;
+      }
+      const sig = keyring.sign(req, SEED_NONCE_BASE + i);
+      const axiom = await this.axioms.mint(req, sig);
+      await this.audit.append({
+        kind: "axiom-mint",
+        data: { axiomId: axiom.id, rank: axiom.rank, source: axiom.source, origin: "seed" }
+      });
+      minted++;
+    }
+    return { minted, skipped };
+  }
+  async mintAxiom(req, sig) {
+    const axiom = await this.axioms.mint(req, sig);
+    await this.audit.append({
+      kind: "axiom-mint",
+      data: { axiomId: axiom.id, rank: axiom.rank, source: axiom.source, origin: "custom" }
+    });
+    return axiom;
+  }
+  async listAxioms(filter) {
+    return this.axioms.list(filter);
+  }
+  async getAxiom(id) {
+    return this.axioms.get(id);
+  }
+  /**
+   * Project the Ontological Kernel (OKL) of this MAIC instance or of a registered HIM.
+   *
+   * The OKL is the typed projection described in `THE_SOUL_OF_THE_MACHINE.md`
+   * §3.1 + Appendix A.2.1: a `metaAxiomId` hoisted at position 0, the remaining
+   * axioms ordered by rank hierarchy (`meta → primary → secondary`), optionally
+   * narrowed by `jurisdiction` and tagged with a `himId`.
+   *
+   * Without `himId`: returns the kernel of the root MAIC corpus (every axiom
+   * currently in the store). With `himId`: returns the HIM-specific kernel
+   * built from `axiomsSnapshot ∪ emergentAxioms`, tagged with the HIM id so
+   * downstream tooling (Φ′ runner, compliance auditors) can attribute the
+   * kernel. Throws when `himId` does not resolve to a registered HIM.
+   *
+   * Closes TASK.md D-M6.
+   */
+  async getOntologicalKernel(himId, opts = {}) {
+    if (himId === void 0) {
+      const axioms2 = await this.listAxioms();
+      return projectOntologicalKernel(axioms2, opts);
+    }
+    const him = await this.getHimRecord(himId);
+    if (!him) {
+      throw new Error(`HIM not registered: ${himId}`);
+    }
+    const axioms = [...him.axiomsSnapshot, ...him.emergentAxioms];
+    return projectOntologicalKernel(axioms, { ...opts, himId });
+  }
+  /**
+   * Register a HIM in this MAIC instance. Snapshots the current axiom corpus
+   * (the HIM's inherited axioms at birth) and emits a `him-register` audit event.
+   *
+   * Future axiom mints in MAIC do NOT retroactively change a HIM's snapshot;
+   * HIM-emergent evolutions land via a separate channel (see `proposeAxiomEvolution`).
+   */
+  async registerHim(birthSig, creatorSig) {
+    const parsed = BirthSignature.parse(birthSig);
+    const axiomsSnapshot = await this.axioms.list();
+    const audit = await this.audit.append({
+      kind: "him-register",
+      data: {
+        himId: parsed.himId,
+        primaryArchetype: parsed.primaryArchetype,
+        bornAt: parsed.bornAt,
+        axiomCount: axiomsSnapshot.length
+      }
+    });
+    return this.hims.register(parsed, creatorSig, axiomsSnapshot, audit.auditId);
+  }
+  async getHimRecord(himId) {
+    return this.hims.get(himId);
+  }
+  async listHims() {
+    return this.hims.list();
+  }
+  /**
+   * Reincarnate a HIM into a new NHE body (Entries 3 + 4 + J-H3 lifecycle).
+   * Same HIM persists; new NHE inherits axiom snapshot from registration time.
+   * Previous open body (if `req.fromNheId` given) is closed atomically.
+   *
+   * Requires a Creator signature over the canonical request payload.
+   *
+   * Audit emission (closes F6 + F7 from the 2026-05-24 him deep audit):
+   *
+   *   - When `opts.lifecycle` is **omitted**, emits the generic
+   *     `him-reincarnate` audit kind (legacy / backward-compatible path).
+   *     `data` carries `himId`, `fromNheId`, `toNheId`, `toLlmAdapter`,
+   *     `reason`, `bodyHistoryLength`.
+   *   - When `opts.lifecycle` is **provided** (`model-swap` /
+   *     `version-bump` / `return-from-limbo`), emits the typed
+   *     `reincarnate:${lifecycle}` audit kind instead, with the same
+   *     `data` shape plus a redundant `lifecycle` field so consumers
+   *     reading either the `kind` or `data` can recover the
+   *     classification.
+   *
+   * `@teleologyhi-sdk/him`'s `reincarnate` helper always supplies a
+   * lifecycle (defaulting to `"model-swap"`), so HIM-routed events
+   * always land under the typed kinds. Direct `maic.reincarnateHim`
+   * callers that ignore `opts` keep getting `him-reincarnate` for
+   * compatibility.
+   */
+  async reincarnateHim(req, creatorSig, opts = {}) {
+    const updated = await this.hims.reincarnate(req, creatorSig);
+    const newBody = updated.bodyHistory[updated.bodyHistory.length - 1];
+    const kind = opts.lifecycle ? `reincarnate:${opts.lifecycle}` : "him-reincarnate";
+    await this.audit.append({
+      kind,
+      data: {
+        himId: req.himId,
+        fromNheId: req.fromNheId ?? null,
+        toNheId: newBody.nheId,
+        toLlmAdapter: newBody.llmAdapter,
+        reason: req.reason ?? null,
+        bodyHistoryLength: updated.bodyHistory.length,
+        ...opts.lifecycle ? { lifecycle: opts.lifecycle } : {}
+      }
+    });
+    return updated;
+  }
+  /**
+   * Lifecycle controls (Entry 5).
+   *
+   *   - `terminate` marks an NHE permanently inactive. NHE.respond/sleep should
+   *     refuse all calls. Reversible only via Creator-signed `reactivate`.
+   *   - `deprecate` marks an NHE as soft-retired. NHE.respond should still work
+   *     but emit a deprecation warning. Reversible via `reactivate`.
+   *   - `reactivate` brings a deprecated or terminated NHE back to active.
+   *
+   * All three require a Creator signature over the canonical request payload.
+   * Unknown nheIds are implicitly active; status records are only persisted
+   * when state changes.
+   */
+  async terminate(nheId, reason, creatorSig) {
+    return this.applyLifecycle({ op: "terminate", nheId, ...reason !== void 0 ? { reason } : {} }, creatorSig);
+  }
+  async deprecate(nheId, reason, creatorSig) {
+    return this.applyLifecycle({ op: "deprecate", nheId, ...reason !== void 0 ? { reason } : {} }, creatorSig);
+  }
+  async reactivate(nheId, reason, creatorSig) {
+    return this.applyLifecycle({ op: "reactivate", nheId, ...reason !== void 0 ? { reason } : {} }, creatorSig);
+  }
+  /** Current status. Returns "active" when no record exists. */
+  async getNheStatus(nheId) {
+    return this.nheStatuses.resolve(nheId);
+  }
+  /** Full status record (or null when never altered). */
+  async getNheStatusRecord(nheId) {
+    return this.nheStatuses.get(nheId);
+  }
+  /** Enumerate NHEs with persisted status (optionally filter by status). */
+  async listNheStatuses(filter = {}) {
+    return this.nheStatuses.list(filter);
+  }
+  async applyLifecycle(req, sig) {
+    const updated = await this.nheStatuses.apply(req, sig);
+    await this.audit.append({
+      kind: req.op === "terminate" ? "terminate" : req.op === "deprecate" ? "deprecate" : "reactivate",
+      data: {
+        nheId: req.nheId,
+        status: updated.status,
+        reason: req.reason ?? null,
+        since: updated.since
+      }
+    });
+    return updated;
+  }
+  /**
+   * Queue a dream-induction ticket for the given NHE (Entry 2).
+   *
+   * NHE picks the oldest pending ticket on its next sleep cycle, runs REM with
+   * the configured scenario, then marks the ticket consumed. Tickets persist
+   * across restarts and are reflected in the audit log.
+   */
+  async induceDream(nheId, intent) {
+    const ticket = await this.inductions.induce(nheId, intent);
+    await this.audit.append({
+      kind: "dream-induce",
+      data: {
+        nheId,
+        ticketId: ticket.id,
+        inducedBy: intent.inducedBy,
+        scenario: intent.scenario,
+        desiredLearning: intent.desiredLearning
+      }
+    });
+    return ticket;
+  }
+  /** List pending induction tickets for an NHE (oldest first). */
+  async listPendingInductions(nheId) {
+    return this.inductions.listPending(nheId);
+  }
+  /** Look up any induction ticket by id. */
+  async getInduction(ticketId) {
+    return this.inductions.get(ticketId);
+  }
+  /** Cancel a pending induction. Idempotent only when already-cancelled tickets are rejected. */
+  async cancelInduction(ticketId, reason) {
+    const updated = await this.inductions.cancel(ticketId, reason);
+    await this.audit.append({
+      kind: "dream-cancel",
+      data: { nheId: updated.nheId, ticketId, reason: reason ?? null }
+    });
+    return updated;
+  }
+  /** Mark a pending ticket as consumed (NHE calls this after successful sleep). */
+  async consumeInduction(ticketId) {
+    const updated = await this.inductions.consume(ticketId);
+    await this.audit.append({
+      kind: "dream-consume",
+      data: { nheId: updated.nheId, ticketId }
+    });
+    return updated;
+  }
+  /**
+   * Review a behavior report against the active rule packs. The verdict is
+   * logged to the audit chain as a single tamper-evident event whose auditId
+   * becomes the verdict's `auditId`.
+   */
+  async reviewBehavior(report) {
+    const parsed = BehaviorReport.parse(report);
+    const partial = this.review.review(parsed);
+    const event = await this.audit.append({
+      kind: "behavior-review",
+      data: {
+        nheId: parsed.nheId,
+        himId: parsed.himId,
+        actionKind: parsed.actionKind,
+        riskTags: parsed.riskTags,
+        verdict: partial
+      }
+    });
+    return { ...partial, auditId: event.auditId };
+  }
+  /**
+   * Queue a HIM-emergent axiom proposal (Entry 7). The proposal enters
+   * `pending` status; the Creator decides out of band via `ratifyAxiomProposal`
+   * or `rejectAxiomProposal`. Emits a `proposal-emerge` audit event.
+   *
+   * Returns an `AxiomEvolutionResult` with `outcome: "deferred-for-creator-review"`
+   * and `proposalId`. Poll `getAxiomProposal(proposalId)` for the final state.
+   */
+  async proposeAxiomEvolution(himId, proposal) {
+    if (!await this.hims.get(himId)) {
+      throw new Error(`LocalMaic.proposeAxiomEvolution: himId "${himId}" not registered`);
+    }
+    const record = await this.proposals.propose(himId, proposal);
+    await this.audit.append({
+      kind: "proposal-emerge",
+      data: {
+        himId,
+        proposalId: record.id,
+        rank: proposal.candidate.rank,
+        statement: proposal.candidate.statement,
+        derivedFromDreamIds: proposal.derivedFromDreamIds,
+        derivedFromInteractionIds: proposal.derivedFromInteractionIds
+      }
+    });
+    return {
+      outcome: "deferred-for-creator-review",
+      proposalId: record.id
+    };
+  }
+  /** Look up a proposal by id (or null when not found). */
+  async getAxiomProposal(proposalId) {
+    return this.proposals.get(proposalId);
+  }
+  /** List proposals, optionally filtered by `himId` and/or `status`. */
+  async listAxiomProposals(filter = {}) {
+    return this.proposals.list(filter);
+  }
+  /**
+   * Ratify a pending proposal (Creator-signed). On success, mints the
+   * candidate as a new `Axiom` (source: "him-emergent"), appends to the
+   * HIM's `emergentAxioms`, and emits a `proposal-ratify` audit event.
+   * Throws if the proposal is not pending or the signature is invalid.
+   */
+  async ratifyAxiomProposal(proposalId, creatorSig) {
+    const req = { op: "ratify", proposalId };
+    const pending = this.proposals.get(proposalId);
+    const record = await pending;
+    if (!record) {
+      throw new Error(`LocalMaic.ratifyAxiomProposal: proposal "${proposalId}" not found`);
+    }
+    const candidate = record.proposal.candidate;
+    const newAxiomId = `ax.him.${record.himId}.${ulid()}`;
+    const axiom = {
+      id: newAxiomId,
+      rank: candidate.rank,
+      statement: candidate.statement,
+      weight: candidate.weight,
+      flexibility: candidate.flexibility,
+      source: "him-emergent",
+      immutable: candidate.immutable,
+      ...candidate.jurisdictions ? { jurisdictions: candidate.jurisdictions } : {},
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const ratified = await this.proposals.markRatified(req, creatorSig, newAxiomId);
+    await this.hims.appendEmergentAxiom(record.himId, axiom);
+    await this.audit.append({
+      kind: "proposal-ratify",
+      data: {
+        himId: record.himId,
+        proposalId,
+        axiomId: newAxiomId,
+        rank: axiom.rank
+      }
+    });
+    return { proposal: ratified, axiom };
+  }
+  /**
+   * Reject a pending proposal (Creator-signed). Records the rejection on the
+   * proposal record (status → "rejected" + timestamp + optional reason) and
+   * emits a `proposal-reject` audit event.
+   */
+  async rejectAxiomProposal(proposalId, reason, creatorSig) {
+    const req = {
+      op: "reject",
+      proposalId,
+      ...reason !== void 0 ? { reason } : {}
+    };
+    const rejected = await this.proposals.markRejected(req, creatorSig);
+    await this.audit.append({
+      kind: "proposal-reject",
+      data: {
+        himId: rejected.himId,
+        proposalId,
+        reason: reason ?? null
+      }
+    });
+    return rejected;
+  }
+  /**
+   * **Society of HIMs — axiom suggestion channel (E11).**
+   *
+   * One HIM proposes an axiom to another. The transfer is **not direct** —
+   * the suggestion is recorded in the audit log and the receiving HIM is
+   * expected to relay it through `proposeAxiomEvolution` as if it had
+   * derived the candidate itself; the Creator still ratifies via the
+   * existing channel. This preserves the Kardecist invariant ("each
+   * spirit evolves through lived experience") while permitting cross-HIM
+   * cross-pollination.
+   *
+   * The Creator must sign the suggestion request so HIMs cannot collude
+   * around the gate.
+   */
+  async suggestAxiomToHim(req, creatorSig) {
+    if (!CreatorKeyring.verifyWith(this.creatorPublicKey, req, creatorSig)) {
+      throw new Error("LocalMaic.suggestAxiomToHim: invalid Creator signature");
+    }
+    const fromRec = await this.hims.get(req.fromHimId);
+    const toRec = await this.hims.get(req.toHimId);
+    if (!fromRec) {
+      throw new Error(
+        `LocalMaic.suggestAxiomToHim: fromHimId "${req.fromHimId}" not registered`
+      );
+    }
+    if (!toRec) {
+      throw new Error(
+        `LocalMaic.suggestAxiomToHim: toHimId "${req.toHimId}" not registered`
+      );
+    }
+    const event = await this.audit.append({
+      kind: "axiom-suggest",
+      data: {
+        fromHimId: req.fromHimId,
+        toHimId: req.toHimId,
+        statement: req.statement,
+        rank: req.rank,
+        rationale: req.rationale ?? null
+      }
+    });
+    return { auditId: event.auditId };
+  }
+  /**
+   * Project the audit log into compliance evidence for a target framework
+   * (Entry 5 + RESEARCH_DOSSIER §5.6). Group every recorded event by which
+   * control(s) it supports; surface `uncoveredKinds` for events the mapper
+   * does not yet know how to project.
+   */
+  async toCompliance(framework, opts = {}) {
+    return ComplianceMapper.project(this.audit, framework, opts);
+  }
+  /** Query the audit log. */
+  queryAudit(filter) {
+    return this.audit.query(filter);
+  }
+  /** Number of audit events recorded since the store was opened. */
+  auditSize() {
+    return this.audit.size();
+  }
+  /**
+   * Per-kind retention classification (E3). Tells the operator which
+   * audit events have aged past their retention window and should be
+   * moved to encrypted cold-storage. Tamper-evident hash chain forbids
+   * actual deletion in-place — this method only classifies. See
+   * `audit/retention.ts` for the policy defaults.
+   */
+  async auditRetentionReport(opts = {}) {
+    const events = [];
+    for await (const e of this.audit.query({})) events.push(e);
+    return evaluateRetention(events, opts);
+  }
+};
+var SEED_NONCE_BASE = 4294901760;
+
+// src/client/remote.ts
+var RemoteMaic = class {
+  baseUrl;
+  apiKey;
+  fetchFn;
+  timeoutMs;
+  constructor(config) {
+    if (!config.baseUrl) {
+      throw new Error("RemoteMaic: baseUrl is required");
+    }
+    this.baseUrl = config.baseUrl.replace(/\/$/, "");
+    if (config.apiKey !== void 0) this.apiKey = config.apiKey;
+    this.fetchFn = config.fetch ?? globalThis.fetch;
+    this.timeoutMs = config.timeoutMs ?? 1e4;
+  }
+  /**
+   * `reviewBehavior` is **fail-closed** (E4 — PROPOSED_DECISIONS.md). If the
+   * remote service is unreachable, throw — no governance, no response.
+   * The NHE will surface this as a refusal upstream.
+   */
+  async reviewBehavior(report) {
+    return this.request("POST", "/v1/behavior-review", report);
+  }
+  /**
+   * `getNheStatus` defaults to **"active"** when unreachable (E4). The
+   * Kardecist invariant: an unreachable governance doesn't kill the
+   * spirit. Operators who want fail-closed on lifecycle should wrap with
+   * a watchdog that hard-fails the deployment when the remote drops.
+   */
+  async getNheStatus(nheId) {
+    try {
+      const body = await this.request(
+        "GET",
+        `/v1/nhes/${encodeURIComponent(nheId)}/status`
+      );
+      return body.status;
+    } catch {
+      return "active";
+    }
+  }
+  /**
+   * `listPendingInductions` is **fail-open** (E4). No inductions = NHE
+   * skips them and continues the sleep cycle; this is best-effort by
+   * design.
+   */
+  async listPendingInductions(nheId) {
+    try {
+      const body = await this.request(
+        "GET",
+        `/v1/nhes/${encodeURIComponent(nheId)}/inductions/pending`
+      );
+      return body.tickets;
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * `consumeInduction` is **fail-open** (E4). If the consume call fails, we
+   * return a synthetic *pending* placeholder so the caller treats the
+   * induction as still-unconsumed and re-tries on the next sleep cycle.
+   *
+   * The placeholder uses placeholder values (`nheId: "unknown"`, epoch
+   * `createdAt`) so it is visibly synthetic in logs/audits, but the shape
+   * is **strictly valid**: `status === "pending"` carries no
+   * `cancelReason`/`cancelledAt`/`consumedAt`, which avoids the
+   * shape-contradiction of a "pending ticket with a cancel reason".
+   * Operators who need the transport-failure reason should observe the
+   * underlying fetch error (e.g. via OpenTelemetry traces) rather than
+   * trying to read it off the ticket.
+   */
+  async consumeInduction(ticketId) {
+    try {
+      return await this.request(
+        "POST",
+        `/v1/inductions/${encodeURIComponent(ticketId)}/consume`
+      );
+    } catch {
+      return {
+        id: ticketId,
+        nheId: "unknown",
+        intent: { scenario: "", desiredLearning: "", inducedBy: "maic" },
+        status: "pending",
+        createdAt: (/* @__PURE__ */ new Date(0)).toISOString()
+      };
+    }
+  }
+  async request(method, path, body) {
+    const url = `${this.baseUrl}${path}`;
+    const headers = { accept: "application/json" };
+    if (this.apiKey) headers.authorization = `Bearer ${this.apiKey}`;
+    if (body !== void 0) headers["content-type"] = "application/json";
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+    try {
+      const init = { method, headers, signal: controller.signal };
+      if (body !== void 0) init.body = JSON.stringify(body);
+      const res = await this.fetchFn(url, init);
+      if (!res.ok) {
+        const text = await safeReadText(res);
+        throw new Error(
+          `RemoteMaic: HTTP ${res.status} ${res.statusText} on ${method} ${path}: ${text}`
+        );
+      }
+      return await res.json();
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+};
+async function safeReadText(r) {
+  try {
+    return await r.text();
+  } catch {
+    return "<unreadable>";
+  }
+}
+
+export { ALL_AUDIT_EVENT_KINDS, Affect, ArchetypeModifier, AstrologicalAspect, AuditLog, Axiom, AxiomProposalRecord, AxiomRank, AxiomSource, AxiomStore, BehaviorReport, BirthSignature, ComplianceMapper, CreatorKeyring, CreatorSignature, DEFAULT_RETENTION_DAYS, DEFAULT_RULE_PACK, DreamInductionIntent, DreamInductionTicket, EU_AI_ACT_MAPPING, EmergentAxiomCandidate, EmergentAxiomProposal, HimStore, ISO_42001_MAPPING, IdentityLayer, IdentitySnapshot, InductionStatus, InductionStore, InteractionRecord, InvalidBirthSignatureError, LimboReturn, LimboState, LimboTransition, LocalMaic, META_AXIOM_ID, MaicVerdict, MemoryRecord, NatalChart, NatalChartAspect, NatalChartPosition, NatalPlanet, NheBodyRef, NheStatus, NheStatusRecord, NheStatusStore, ProposalStatus, ProposalStore, ReasoningStep, RemoteMaic, ReviewPipeline, SEED_AXIOMS, SEED_NONCE_BASE, SIGNED_BIRTH_FIELDS, SemioticPattern, SemioticSign, TeleologicalOrientation, VerdictKind, WakeAffectBias, ZodiacSign, assertBirthSignature, canonicalJSON, evaluateRetention, projectOntologicalKernel, signBirthSignature, signedBirthPayload, verifyBirthSignature };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map