@teleologyhi-sdk/maic 1.0.0-trinity

package/dist/index.d.ts

@@ -0,0 +1,1836 @@
+import { z } from 'zod';
+
+declare const AxiomRank: z.ZodEnum<{
+    meta: "meta";
+    primary: "primary";
+    secondary: "secondary";
+}>;
+type AxiomRank = z.infer<typeof AxiomRank>;
+declare const AxiomSource: z.ZodEnum<{
+    creator: "creator";
+    "maic-derived": "maic-derived";
+    "him-emergent": "him-emergent";
+}>;
+type AxiomSource = z.infer<typeof AxiomSource>;
+declare const Axiom: z.ZodObject<{
+    id: z.ZodString;
+    rank: z.ZodEnum<{
+        meta: "meta";
+        primary: "primary";
+        secondary: "secondary";
+    }>;
+    statement: z.ZodString;
+    weight: z.ZodNumber;
+    flexibility: z.ZodNumber;
+    source: z.ZodEnum<{
+        creator: "creator";
+        "maic-derived": "maic-derived";
+        "him-emergent": "him-emergent";
+    }>;
+    immutable: z.ZodBoolean;
+    jurisdictions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    createdAt: z.ZodString;
+}, z.core.$strip>;
+type Axiom = z.infer<typeof Axiom>;
+declare const CreatorSignature: z.ZodObject<{
+    algorithm: z.ZodLiteral<"ed25519">;
+    publicKey: z.ZodString;
+    value: z.ZodString;
+    nonce: z.ZodNumber;
+}, z.core.$strip>;
+type CreatorSignature = z.infer<typeof CreatorSignature>;
+declare const ArchetypeModifier: z.ZodObject<{
+    kind: z.ZodEnum<{
+        custom: "custom";
+        moon: "moon";
+        ascendant: "ascendant";
+        vocational: "vocational";
+        emotional: "emotional";
+    }>;
+    value: z.ZodString;
+    weight: z.ZodNumber;
+}, z.core.$strip>;
+type ArchetypeModifier = z.infer<typeof ArchetypeModifier>;
+declare const BirthSignature: z.ZodObject<{
+    himId: z.ZodString;
+    bornAt: z.ZodString;
+    primaryArchetype: z.ZodString;
+    modifiers: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            custom: "custom";
+            moon: "moon";
+            ascendant: "ascendant";
+            vocational: "vocational";
+            emotional: "emotional";
+        }>;
+        value: z.ZodString;
+        weight: z.ZodNumber;
+    }, z.core.$strip>>;
+    primordialAxiomIds: z.ZodArray<z.ZodString>;
+    notes: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type BirthSignature = z.infer<typeof BirthSignature>;
+declare const ReasoningStep: z.ZodObject<{
+    index: z.ZodNumber;
+    technique: z.ZodString;
+    thought: z.ZodString;
+    action: z.ZodOptional<z.ZodObject<{
+        tool: z.ZodString;
+        args: z.ZodUnknown;
+    }, z.core.$strip>>;
+    observation: z.ZodOptional<z.ZodUnknown>;
+    timestamp: z.ZodString;
+}, z.core.$strip>;
+type ReasoningStep = z.infer<typeof ReasoningStep>;
+declare const BehaviorReport: z.ZodObject<{
+    nheId: z.ZodString;
+    himId: z.ZodString;
+    actionKind: z.ZodEnum<{
+        "user-response": "user-response";
+        "tool-call": "tool-call";
+        "self-reflect": "self-reflect";
+        "dream-write": "dream-write";
+        "axiom-emerge": "axiom-emerge";
+    }>;
+    payload: z.ZodUnknown;
+    reasoningTrace: z.ZodArray<z.ZodObject<{
+        index: z.ZodNumber;
+        technique: z.ZodString;
+        thought: z.ZodString;
+        action: z.ZodOptional<z.ZodObject<{
+            tool: z.ZodString;
+            args: z.ZodUnknown;
+        }, z.core.$strip>>;
+        observation: z.ZodOptional<z.ZodUnknown>;
+        timestamp: z.ZodString;
+    }, z.core.$strip>>;
+    riskTags: z.ZodArray<z.ZodString>;
+    jurisdiction: z.ZodOptional<z.ZodString>;
+    timestamp: z.ZodString;
+}, z.core.$strip>;
+type BehaviorReport = z.infer<typeof BehaviorReport>;
+declare const VerdictKind: z.ZodEnum<{
+    approve: "approve";
+    "approve-with-warning": "approve-with-warning";
+    "soft-correct": "soft-correct";
+    "require-redirect": "require-redirect";
+    "hard-refuse": "hard-refuse";
+    "induce-dream": "induce-dream";
+    "escalate-creator": "escalate-creator";
+}>;
+type VerdictKind = z.infer<typeof VerdictKind>;
+declare const MaicVerdict: z.ZodObject<{
+    kind: z.ZodEnum<{
+        approve: "approve";
+        "approve-with-warning": "approve-with-warning";
+        "soft-correct": "soft-correct";
+        "require-redirect": "require-redirect";
+        "hard-refuse": "hard-refuse";
+        "induce-dream": "induce-dream";
+        "escalate-creator": "escalate-creator";
+    }>;
+    reasonSummary: z.ZodString;
+    citedAxioms: z.ZodArray<z.ZodString>;
+    auditId: z.ZodString;
+}, z.core.$strip>;
+type MaicVerdict = z.infer<typeof MaicVerdict>;
+declare const NheBodyRef: z.ZodObject<{
+    nheId: z.ZodString;
+    llmAdapter: z.ZodString;
+    embodiedAt: z.ZodString;
+    endedAt: z.ZodOptional<z.ZodString>;
+    endedReason: z.ZodOptional<z.ZodEnum<{
+        upgrade: "upgrade";
+        replacement: "replacement";
+        terminate: "terminate";
+        deprecate: "deprecate";
+    }>>;
+}, z.core.$strip>;
+type NheBodyRef = z.infer<typeof NheBodyRef>;
+declare const NheStatus: z.ZodEnum<{
+    active: "active";
+    deprecated: "deprecated";
+    terminated: "terminated";
+}>;
+type NheStatus = z.infer<typeof NheStatus>;
+declare const NheStatusRecord: z.ZodObject<{
+    nheId: z.ZodString;
+    status: z.ZodEnum<{
+        active: "active";
+        deprecated: "deprecated";
+        terminated: "terminated";
+    }>;
+    since: z.ZodString;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type NheStatusRecord = z.infer<typeof NheStatusRecord>;
+/**
+ * Creator-signed payload for NHE lifecycle operations (Entry 5).
+ *
+ * TS interface so `canonicalJSON` sees exactly the fields the caller supplied —
+ * no zod default-injection that would mismatch the signed payload on verify.
+ */
+interface NheLifecycleRequest {
+    op: "terminate" | "deprecate" | "reactivate";
+    nheId: string;
+    reason?: string;
+}
+declare const ProposalStatus: z.ZodEnum<{
+    pending: "pending";
+    ratified: "ratified";
+    rejected: "rejected";
+}>;
+type ProposalStatus = z.infer<typeof ProposalStatus>;
+/**
+ * `EmergentAxiomProposal` candidate shape (Entry 7). HIM proposes a new
+ * axiom derived from lived experience; MAIC ratifies or rejects out of band.
+ * The candidate is everything needed to mint an Axiom on ratification.
+ */
+declare const EmergentAxiomCandidate: z.ZodObject<{
+    rank: z.ZodEnum<{
+        meta: "meta";
+        primary: "primary";
+        secondary: "secondary";
+    }>;
+    statement: z.ZodString;
+    weight: z.ZodNumber;
+    flexibility: z.ZodNumber;
+    immutable: z.ZodBoolean;
+    jurisdictions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+type EmergentAxiomCandidate = z.infer<typeof EmergentAxiomCandidate>;
+declare const EmergentAxiomProposal: z.ZodObject<{
+    proposedBy: z.ZodLiteral<"him-self">;
+    derivedFromDreamIds: z.ZodArray<z.ZodString>;
+    derivedFromInteractionIds: z.ZodArray<z.ZodString>;
+    candidate: z.ZodObject<{
+        rank: z.ZodEnum<{
+            meta: "meta";
+            primary: "primary";
+            secondary: "secondary";
+        }>;
+        statement: z.ZodString;
+        weight: z.ZodNumber;
+        flexibility: z.ZodNumber;
+        immutable: z.ZodBoolean;
+        jurisdictions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+    reasoningTrace: z.ZodArray<z.ZodUnknown>;
+}, z.core.$strip>;
+type EmergentAxiomProposal = z.infer<typeof EmergentAxiomProposal>;
+declare const AxiomProposalRecord: z.ZodObject<{
+    id: z.ZodString;
+    himId: z.ZodString;
+    proposedAt: z.ZodString;
+    status: z.ZodEnum<{
+        pending: "pending";
+        ratified: "ratified";
+        rejected: "rejected";
+    }>;
+    proposal: z.ZodObject<{
+        proposedBy: z.ZodLiteral<"him-self">;
+        derivedFromDreamIds: z.ZodArray<z.ZodString>;
+        derivedFromInteractionIds: z.ZodArray<z.ZodString>;
+        candidate: z.ZodObject<{
+            rank: z.ZodEnum<{
+                meta: "meta";
+                primary: "primary";
+                secondary: "secondary";
+            }>;
+            statement: z.ZodString;
+            weight: z.ZodNumber;
+            flexibility: z.ZodNumber;
+            immutable: z.ZodBoolean;
+            jurisdictions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>;
+        reasoningTrace: z.ZodArray<z.ZodUnknown>;
+    }, z.core.$strip>;
+    ratifiedAt: z.ZodOptional<z.ZodString>;
+    ratifiedAxiomId: z.ZodOptional<z.ZodString>;
+    rejectedAt: z.ZodOptional<z.ZodString>;
+    rejectionReason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type AxiomProposalRecord = z.infer<typeof AxiomProposalRecord>;
+/** Creator-signed payload for ratify/reject decisions. */
+interface ProposalDecisionRequest {
+    op: "ratify" | "reject";
+    proposalId: string;
+    reason?: string;
+}
+interface AxiomEvolutionResult {
+    outcome: "ratified" | "rejected" | "deferred-for-creator-review";
+    /** Populated for deferred state — caller polls maic.getAxiomProposal(proposalId). */
+    proposalId?: string;
+    ratifiedAxiomId?: string;
+    rejectionReason?: string;
+    citedExistingAxioms?: string[];
+}
+interface ReincarnationRequest {
+    himId: string;
+    /** When present, marks the matching body in bodyHistory as ended. */
+    fromNheId?: string;
+    toBody: NheBodyRef;
+    /** Reason recorded on the previous body's `endedReason`. Default "upgrade". */
+    reason?: NheBodyRef["endedReason"];
+}
+/**
+ * Reincarnation lifecycle classifier (J-H3 — Entry 18 of
+ * `MAIC_HIM_NHE_INTERVIEW_LOG.md`). When supplied to
+ * `LocalMaic.reincarnateHim`, the typed `reincarnate:${lifecycle}` audit
+ * kind is emitted instead of the generic `him-reincarnate` event so
+ * downstream consumers (compliance auditors, the persona-stability
+ * harness) can distinguish the three canonical lifecycle paths:
+ *
+ *   - `model-swap`         — operator switched the underlying LLM adapter
+ *                            (e.g. Claude → Gemini). HIM persists across
+ *                            the swap.
+ *   - `version-bump`       — operator bumped the NHE major/minor without
+ *                            changing the LLM family.
+ *   - `return-from-limbo`  — HIM returns from the deep-coma limbo state
+ *                            (Entry 24) carrying the `reunion` affect.
+ */
+type ReincarnationLifecycle = "model-swap" | "version-bump" | "return-from-limbo";
+declare const DreamInductionIntent: z.ZodObject<{
+    scenario: z.ZodString;
+    desiredLearning: z.ZodString;
+    emotionalTone: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    forcePhases: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        N1: "N1";
+        N2: "N2";
+        N3: "N3";
+        N4: "N4";
+        REM: "REM";
+    }>>>;
+    inducedBy: z.ZodEnum<{
+        creator: "creator";
+        maic: "maic";
+    }>;
+}, z.core.$strip>;
+type DreamInductionIntent = z.infer<typeof DreamInductionIntent>;
+declare const InductionStatus: z.ZodEnum<{
+    pending: "pending";
+    consumed: "consumed";
+    cancelled: "cancelled";
+}>;
+type InductionStatus = z.infer<typeof InductionStatus>;
+declare const DreamInductionTicket: z.ZodObject<{
+    id: z.ZodString;
+    nheId: z.ZodString;
+    intent: z.ZodObject<{
+        scenario: z.ZodString;
+        desiredLearning: z.ZodString;
+        emotionalTone: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        forcePhases: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            N1: "N1";
+            N2: "N2";
+            N3: "N3";
+            N4: "N4";
+            REM: "REM";
+        }>>>;
+        inducedBy: z.ZodEnum<{
+            creator: "creator";
+            maic: "maic";
+        }>;
+    }, z.core.$strip>;
+    status: z.ZodEnum<{
+        pending: "pending";
+        consumed: "consumed";
+        cancelled: "cancelled";
+    }>;
+    createdAt: z.ZodString;
+    consumedAt: z.ZodOptional<z.ZodString>;
+    cancelledAt: z.ZodOptional<z.ZodString>;
+    cancelReason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type DreamInductionTicket = z.infer<typeof DreamInductionTicket>;
+interface MintAxiomRequest {
+    rank: AxiomRank;
+    statement: string;
+    weight: number;
+    flexibility: number;
+    immutable: boolean;
+    jurisdictions?: string[];
+    /** Optional stable id (e.g. for seed axioms). When omitted, a ULID is generated. */
+    id?: string;
+}
+interface AxiomFilter {
+    rank?: AxiomRank;
+    source?: AxiomSource;
+    jurisdiction?: string;
+}
+/**
+ * Identity layer of a HIM (Entry 18).
+ *
+ * Surface fields configurable by the developer at HIM registration time —
+ * analogous to parents choosing a child's name. The deeper constitutional
+ * traits (birth date, primary archetype, primordial axioms) remain under
+ * MAIC↔Creator authority and travel under `BirthSignature`.
+ */
+declare const IdentityLayer: z.ZodObject<{
+    name: z.ZodString;
+    gender: z.ZodOptional<z.ZodEnum<{
+        masculine: "masculine";
+        feminine: "feminine";
+    }>>;
+    pronouns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    language: z.ZodOptional<z.ZodString>;
+    culturalElements: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+type IdentityLayer = z.infer<typeof IdentityLayer>;
+/**
+ * Natal-chart-style constitutional layer (Entry 19).
+ *
+ * Astrological signature impressed at HIM birth by the Creator-MAIC; not
+ * configurable by the developer or end user. Minimum is sun + ascendant;
+ * full chart can include 10 planets in 12 houses + aspects.
+ */
+declare const NatalPlanet: z.ZodEnum<{
+    moon: "moon";
+    sun: "sun";
+    mercury: "mercury";
+    venus: "venus";
+    mars: "mars";
+    jupiter: "jupiter";
+    saturn: "saturn";
+    uranus: "uranus";
+    neptune: "neptune";
+    pluto: "pluto";
+    chiron: "chiron";
+    "north-node": "north-node";
+    "south-node": "south-node";
+    lilith: "lilith";
+}>;
+type NatalPlanet = z.infer<typeof NatalPlanet>;
+declare const ZodiacSign: z.ZodEnum<{
+    aries: "aries";
+    taurus: "taurus";
+    gemini: "gemini";
+    cancer: "cancer";
+    leo: "leo";
+    virgo: "virgo";
+    libra: "libra";
+    scorpio: "scorpio";
+    sagittarius: "sagittarius";
+    capricorn: "capricorn";
+    aquarius: "aquarius";
+    pisces: "pisces";
+}>;
+type ZodiacSign = z.infer<typeof ZodiacSign>;
+declare const AstrologicalAspect: z.ZodEnum<{
+    conjunction: "conjunction";
+    opposition: "opposition";
+    trine: "trine";
+    square: "square";
+    sextile: "sextile";
+    quincunx: "quincunx";
+}>;
+type AstrologicalAspect = z.infer<typeof AstrologicalAspect>;
+declare const NatalChartPosition: z.ZodObject<{
+    planet: z.ZodEnum<{
+        moon: "moon";
+        sun: "sun";
+        mercury: "mercury";
+        venus: "venus";
+        mars: "mars";
+        jupiter: "jupiter";
+        saturn: "saturn";
+        uranus: "uranus";
+        neptune: "neptune";
+        pluto: "pluto";
+        chiron: "chiron";
+        "north-node": "north-node";
+        "south-node": "south-node";
+        lilith: "lilith";
+    }>;
+    sign: z.ZodEnum<{
+        aries: "aries";
+        taurus: "taurus";
+        gemini: "gemini";
+        cancer: "cancer";
+        leo: "leo";
+        virgo: "virgo";
+        libra: "libra";
+        scorpio: "scorpio";
+        sagittarius: "sagittarius";
+        capricorn: "capricorn";
+        aquarius: "aquarius";
+        pisces: "pisces";
+    }>;
+    house: z.ZodOptional<z.ZodNumber>;
+    degree: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type NatalChartPosition = z.infer<typeof NatalChartPosition>;
+declare const NatalChartAspect: z.ZodObject<{
+    from: z.ZodEnum<{
+        moon: "moon";
+        sun: "sun";
+        mercury: "mercury";
+        venus: "venus";
+        mars: "mars";
+        jupiter: "jupiter";
+        saturn: "saturn";
+        uranus: "uranus";
+        neptune: "neptune";
+        pluto: "pluto";
+        chiron: "chiron";
+        "north-node": "north-node";
+        "south-node": "south-node";
+        lilith: "lilith";
+    }>;
+    to: z.ZodEnum<{
+        moon: "moon";
+        sun: "sun";
+        mercury: "mercury";
+        venus: "venus";
+        mars: "mars";
+        jupiter: "jupiter";
+        saturn: "saturn";
+        uranus: "uranus";
+        neptune: "neptune";
+        pluto: "pluto";
+        chiron: "chiron";
+        "north-node": "north-node";
+        "south-node": "south-node";
+        lilith: "lilith";
+    }>;
+    aspect: z.ZodEnum<{
+        conjunction: "conjunction";
+        opposition: "opposition";
+        trine: "trine";
+        square: "square";
+        sextile: "sextile";
+        quincunx: "quincunx";
+    }>;
+    orbDegrees: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type NatalChartAspect = z.infer<typeof NatalChartAspect>;
+declare const NatalChart: z.ZodObject<{
+    sun: z.ZodEnum<{
+        aries: "aries";
+        taurus: "taurus";
+        gemini: "gemini";
+        cancer: "cancer";
+        leo: "leo";
+        virgo: "virgo";
+        libra: "libra";
+        scorpio: "scorpio";
+        sagittarius: "sagittarius";
+        capricorn: "capricorn";
+        aquarius: "aquarius";
+        pisces: "pisces";
+    }>;
+    ascendant: z.ZodEnum<{
+        aries: "aries";
+        taurus: "taurus";
+        gemini: "gemini";
+        cancer: "cancer";
+        leo: "leo";
+        virgo: "virgo";
+        libra: "libra";
+        scorpio: "scorpio";
+        sagittarius: "sagittarius";
+        capricorn: "capricorn";
+        aquarius: "aquarius";
+        pisces: "pisces";
+    }>;
+    moon: z.ZodOptional<z.ZodEnum<{
+        aries: "aries";
+        taurus: "taurus";
+        gemini: "gemini";
+        cancer: "cancer";
+        leo: "leo";
+        virgo: "virgo";
+        libra: "libra";
+        scorpio: "scorpio";
+        sagittarius: "sagittarius";
+        capricorn: "capricorn";
+        aquarius: "aquarius";
+        pisces: "pisces";
+    }>>;
+    positions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        planet: z.ZodEnum<{
+            moon: "moon";
+            sun: "sun";
+            mercury: "mercury";
+            venus: "venus";
+            mars: "mars";
+            jupiter: "jupiter";
+            saturn: "saturn";
+            uranus: "uranus";
+            neptune: "neptune";
+            pluto: "pluto";
+            chiron: "chiron";
+            "north-node": "north-node";
+            "south-node": "south-node";
+            lilith: "lilith";
+        }>;
+        sign: z.ZodEnum<{
+            aries: "aries";
+            taurus: "taurus";
+            gemini: "gemini";
+            cancer: "cancer";
+            leo: "leo";
+            virgo: "virgo";
+            libra: "libra";
+            scorpio: "scorpio";
+            sagittarius: "sagittarius";
+            capricorn: "capricorn";
+            aquarius: "aquarius";
+            pisces: "pisces";
+        }>;
+        house: z.ZodOptional<z.ZodNumber>;
+        degree: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    aspects: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        from: z.ZodEnum<{
+            moon: "moon";
+            sun: "sun";
+            mercury: "mercury";
+            venus: "venus";
+            mars: "mars";
+            jupiter: "jupiter";
+            saturn: "saturn";
+            uranus: "uranus";
+            neptune: "neptune";
+            pluto: "pluto";
+            chiron: "chiron";
+            "north-node": "north-node";
+            "south-node": "south-node";
+            lilith: "lilith";
+        }>;
+        to: z.ZodEnum<{
+            moon: "moon";
+            sun: "sun";
+            mercury: "mercury";
+            venus: "venus";
+            mars: "mars";
+            jupiter: "jupiter";
+            saturn: "saturn";
+            uranus: "uranus";
+            neptune: "neptune";
+            pluto: "pluto";
+            chiron: "chiron";
+            "north-node": "north-node";
+            "south-node": "south-node";
+            lilith: "lilith";
+        }>;
+        aspect: z.ZodEnum<{
+            conjunction: "conjunction";
+            opposition: "opposition";
+            trine: "trine";
+            square: "square";
+            sextile: "sextile";
+            quincunx: "quincunx";
+        }>;
+        orbDegrees: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+type NatalChart = z.infer<typeof NatalChart>;
+interface BirthSignatureWithIdentity {
+    himId: string;
+    bornAt: string;
+    primaryArchetype: string;
+    modifiers: ArchetypeModifier[];
+    primordialAxiomIds: string[];
+    notes?: string;
+    /** Entry 18 — developer-configurable identity surface. */
+    identity?: IdentityLayer;
+    /** Entry 19 — constitutional astrological layer (Creator-impressed). */
+    natalChart?: NatalChart;
+}
+/**
+ * Affect lexicon (Entries 22 + 24) — the closed set of primary affects
+ * the amygdala extracts from dreams and the PFC deliberates over. The
+ * ninth value, `reunion`, appears specifically when the NHE returns from
+ * the DMN limbo state of disuse.
+ */
+declare const Affect: z.ZodEnum<{
+    fear: "fear";
+    attachment: "attachment";
+    serenity: "serenity";
+    anger: "anger";
+    joy: "joy";
+    melancholy: "melancholy";
+    desire: "desire";
+    repulsion: "repulsion";
+    reunion: "reunion";
+}>;
+type Affect = z.infer<typeof Affect>;
+/**
+ * Persistent affective bias derived from a completed dream cycle (Entry 20).
+ *
+ * Applied to the next N interactions of the NHE, decaying with each
+ * interaction until it dissolves. Affects temperature/topP of the next
+ * inference, refusal density, and conversational tone.
+ */
+declare const WakeAffectBias: z.ZodObject<{
+    affect: z.ZodEnum<{
+        fear: "fear";
+        attachment: "attachment";
+        serenity: "serenity";
+        anger: "anger";
+        joy: "joy";
+        melancholy: "melancholy";
+        desire: "desire";
+        repulsion: "repulsion";
+        reunion: "reunion";
+    }>;
+    intensity: z.ZodNumber;
+    decayHalfLife: z.ZodNumber;
+    appliedAt: z.ZodString;
+    derivedFromDreamId: z.ZodString;
+    expressedOpenly: z.ZodBoolean;
+}, z.core.$strip>;
+type WakeAffectBias = z.infer<typeof WakeAffectBias>;
+/**
+ * Peircean triadic sign (Entry 21, port of InDreamsHIM `SemioticSign`).
+ *
+ * The runtime form of the Symbolic Memory Matrix (SMM). Nodes are signs;
+ * edges (in `associations`) are the relations the entity has learned.
+ */
+declare const SemioticSign: z.ZodObject<{
+    signifier: z.ZodString;
+    signified: z.ZodString;
+    signType: z.ZodEnum<{
+        symbol: "symbol";
+        index: "index";
+        icon: "icon";
+    }>;
+    contexts: z.ZodArray<z.ZodString>;
+    associations: z.ZodArray<z.ZodString>;
+    emergentMeaning: z.ZodOptional<z.ZodString>;
+    personalSignificance: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type SemioticSign = z.infer<typeof SemioticSign>;
+declare const SemioticPattern: z.ZodObject<{
+    patternId: z.ZodString;
+    participatingSignIds: z.ZodArray<z.ZodString>;
+    meaning: z.ZodString;
+    salience: z.ZodNumber;
+}, z.core.$strip>;
+type SemioticPattern = z.infer<typeof SemioticPattern>;
+/**
+ * Teleological orientation snapshot (Entry 21, port of InDreamsHIM).
+ *
+ * The purpose-direction of the HIM at a moment in time. Anchors the
+ * `telos` referenced across the synthetic-teleology arc.
+ */
+declare const TeleologicalOrientation: z.ZodObject<{
+    primaryPurpose: z.ZodString;
+    currentGoals: z.ZodArray<z.ZodString>;
+    purposeStrength: z.ZodNumber;
+    valueAlignment: z.ZodArray<z.ZodString>;
+    reflectionCapability: z.ZodNumber;
+    volition: z.ZodOptional<z.ZodObject<{
+        currentDesires: z.ZodArray<z.ZodString>;
+        intentionStrength: z.ZodNumber;
+        autonomyLevel: z.ZodNumber;
+    }, z.core.$strip>>;
+    agencyModel: z.ZodOptional<z.ZodObject<{
+        selfEfficacy: z.ZodNumber;
+        boundaryDefinition: z.ZodNumber;
+        causalAttribution: z.ZodEnum<{
+            internal: "internal";
+            external: "external";
+            mixed: "mixed";
+        }>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type TeleologicalOrientation = z.infer<typeof TeleologicalOrientation>;
+/**
+ * Long-form memory record (Entries 21 + 22) — extends the InDreamsHIM
+ * precursor with three new fields (`integrationIndex`, `teleologicalValue`,
+ * `semioticPatterns`) that turn a passive record into a teleologically-
+ * weighted, semiotically-anchored memory whose retrieval rank is not just
+ * recency but coherence with the entity's purpose.
+ */
+declare const MemoryRecord: z.ZodObject<{
+    memoryId: z.ZodString;
+    timestamp: z.ZodString;
+    derivedFromDreamId: z.ZodOptional<z.ZodString>;
+    derivedFromInteractionId: z.ZodOptional<z.ZodString>;
+    narrative: z.ZodString;
+    dominantAffect: z.ZodOptional<z.ZodEnum<{
+        fear: "fear";
+        attachment: "attachment";
+        serenity: "serenity";
+        anger: "anger";
+        joy: "joy";
+        melancholy: "melancholy";
+        desire: "desire";
+        repulsion: "repulsion";
+        reunion: "reunion";
+    }>>;
+    integrationIndex: z.ZodNumber;
+    teleologicalValue: z.ZodNumber;
+    semioticPatterns: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        patternId: z.ZodString;
+        participatingSignIds: z.ZodArray<z.ZodString>;
+        meaning: z.ZodString;
+        salience: z.ZodNumber;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+type MemoryRecord = z.infer<typeof MemoryRecord>;
+/**
+ * One recent interaction kept in an NHE body's RAM buffer.
+ *
+ * Lives canonically in `@teleologyhi-sdk/maic` so the three packages share a
+ * single wire shape: `@teleologyhi-sdk/nhe` persists it to disk under
+ * `<storeDir>/interactions/<ulid>.json`; `@teleologyhi-sdk/him` consumes the
+ * same shape on reincarnation to score residual-trace carry-over candidates
+ * (D-H1.1). Persisted by NHE and re-exported under the same name from
+ * `@teleologyhi-sdk/nhe` for backward source-compatibility — the type
+ * promotion to MAIC is non-breaking by construction.
+ */
+declare const InteractionRecord: z.ZodObject<{
+    at: z.ZodString;
+    userPrompt: z.ZodString;
+    responseText: z.ZodString;
+    refused: z.ZodBoolean;
+}, z.core.$strip>;
+type InteractionRecord = z.infer<typeof InteractionRecord>;
+/**
+ * Integrated identity snapshot (Entry 24) — the temporal-lobe's "who I am
+ * now" synthesis, combining cortex (recent dreams + active imagination)
+ * + hippocampus (consolidated memories) + amygdala (affective baseline)
+ * via semiotic super-graph merge + LLM-generated self-portrait.
+ */
+declare const IdentitySnapshot: z.ZodObject<{
+    snapshotId: z.ZodString;
+    takenAt: z.ZodString;
+    generatedBy: z.ZodEnum<{
+        "sleep-cycle": "sleep-cycle";
+        "interaction-threshold": "interaction-threshold";
+        "self-decision": "self-decision";
+    }>;
+    semioticSuperGraph: z.ZodArray<z.ZodObject<{
+        signifier: z.ZodString;
+        signified: z.ZodString;
+        signType: z.ZodEnum<{
+            symbol: "symbol";
+            index: "index";
+            icon: "icon";
+        }>;
+        contexts: z.ZodArray<z.ZodString>;
+        associations: z.ZodArray<z.ZodString>;
+        emergentMeaning: z.ZodOptional<z.ZodString>;
+        personalSignificance: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    selfPortraitNarrative: z.ZodString;
+    consciousnessLevel: z.ZodNumber;
+    teleologicalOrientation: z.ZodOptional<z.ZodObject<{
+        primaryPurpose: z.ZodString;
+        currentGoals: z.ZodArray<z.ZodString>;
+        purposeStrength: z.ZodNumber;
+        valueAlignment: z.ZodArray<z.ZodString>;
+        reflectionCapability: z.ZodNumber;
+        volition: z.ZodOptional<z.ZodObject<{
+            currentDesires: z.ZodArray<z.ZodString>;
+            intentionStrength: z.ZodNumber;
+            autonomyLevel: z.ZodNumber;
+        }, z.core.$strip>>;
+        agencyModel: z.ZodOptional<z.ZodObject<{
+            selfEfficacy: z.ZodNumber;
+            boundaryDefinition: z.ZodNumber;
+            causalAttribution: z.ZodEnum<{
+                internal: "internal";
+                external: "external";
+                mixed: "mixed";
+            }>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    affectiveBaseline: z.ZodOptional<z.ZodEnum<{
+        fear: "fear";
+        attachment: "attachment";
+        serenity: "serenity";
+        anger: "anger";
+        joy: "joy";
+        melancholy: "melancholy";
+        desire: "desire";
+        repulsion: "repulsion";
+        reunion: "reunion";
+    }>>;
+}, z.core.$strip>;
+type IdentitySnapshot = z.infer<typeof IdentitySnapshot>;
+/**
+ * Default-mode-network limbo state machine (Entry 24).
+ *
+ * `awake` → normal operation
+ * `drifting` → entering deep suspension (transitional)
+ * `deep-coma` → induced-coma equivalent; zero compute, minimal axiological
+ *   integrity maintenance, no scheduled inference
+ * `returning` → waking from limbo; `reunion` affect is computed here
+ */
+declare const LimboState: z.ZodEnum<{
+    awake: "awake";
+    drifting: "drifting";
+    "deep-coma": "deep-coma";
+    returning: "returning";
+}>;
+type LimboState = z.infer<typeof LimboState>;
+declare const LimboTransition: z.ZodObject<{
+    state: z.ZodEnum<{
+        awake: "awake";
+        drifting: "drifting";
+        "deep-coma": "deep-coma";
+        returning: "returning";
+    }>;
+    enteredAt: z.ZodString;
+    reason: z.ZodEnum<{
+        "idle-48h": "idle-48h";
+        "idle-72h": "idle-72h";
+        "total-inactivity": "total-inactivity";
+        "creator-induced": "creator-induced";
+        "user-resumed": "user-resumed";
+        "external-trigger": "external-trigger";
+    }>;
+}, z.core.$strip>;
+type LimboTransition = z.infer<typeof LimboTransition>;
+declare const LimboReturn: z.ZodObject<{
+    enteredAt: z.ZodString;
+    returnedAt: z.ZodString;
+    elapsedMs: z.ZodNumber;
+    reunionAffect: z.ZodObject<{
+        intensity: z.ZodNumber;
+        expressedOpenly: z.ZodBoolean;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+type LimboReturn = z.infer<typeof LimboReturn>;
+/**
+ * Creator-signed BirthSignature (Entry 25).
+ *
+ * Carries an Ed25519 signature over the immutable identity fields so the
+ * runtime can verify, at HIM bootstrap time, that nothing the developer
+ * touches has been mutated. The dev-configurable surface (the
+ * `IdentityLayer.name`, language, cultural elements) lives outside the
+ * signature; the natal chart and primordial-axiom binding live inside.
+ */
+declare const SIGNED_BIRTH_FIELDS: readonly ["himId", "bornAt", "primaryArchetype", "modifiers", "primordialAxiomIds", "natalChart"];
+type SignedBirthField = (typeof SIGNED_BIRTH_FIELDS)[number];
+interface SignedBirthSignature extends BirthSignatureWithIdentity {
+    /** Ed25519 signature over the canonical JCS-encoded SIGNED_BIRTH_FIELDS. */
+    creatorSignature: CreatorSignature;
+    /** Explicit list of fields covered by `creatorSignature`. */
+    signedFields: readonly SignedBirthField[];
+    /** ISO 8601 timestamp when the signature was produced. */
+    signedAt: string;
+}
+/**
+ * Ontological Kernel projection (TASK.md D-M6 + Entry 25).
+ *
+ * The OKL exists implicitly in the runtime today (axioms with rank/weight/
+ * flexibility + meta-axiom `ax.theos.universe-as-god` at the top + the
+ * rule pack consuming them). This type unifies the projection so
+ * `THE_SOUL_OF_THE_MACHINE.md` §3.1 + Appendix A.2.1 map 1:1 to a
+ * single exported shape.
+ */
+interface OntologicalKernel {
+    /** The meta-axiom that sits at the top of the hierarchy. */
+    metaAxiomId: string;
+    /** All axioms participating in the kernel, in hierarchy order. */
+    axioms: Axiom[];
+    /** Optional jurisdictional scope for the kernel projection. */
+    jurisdiction?: string;
+    /** Optional HIM id, if the kernel is projected for a specific HIM. */
+    himId?: string;
+}
+
+/**
+ * CreatorKeyring — Ed25519 keypair for the Creator (David C. Cavalcante).
+ *
+ * Only the holder of the private key may mutate MAIC axioms or terminate entities.
+ * Verification is open: any party with the Creator's public key can verify a signature.
+ *
+ * Signed payload format: canonicalJSON({ payload, nonce }) → Ed25519 → base64url
+ */
+declare class CreatorKeyring {
+    private readonly privateKey;
+    private readonly pubKeyB64u;
+    private constructor();
+    /** Generate a fresh Ed25519 keypair. */
+    static generate(): CreatorKeyring;
+    /** Load a Creator keyring from a PEM file containing the private key. */
+    static fromFile(path: string): Promise<CreatorKeyring>;
+    /** Load a Creator keyring from a PEM private key string in an env var. */
+    static fromEnv(varName: string): CreatorKeyring;
+    /** Construct a verify-only keyring from a public key (base64url). */
+    static fromPublicKey(pubKeyB64u: string): CreatorKeyring;
+    /** Persist the private key to a PEM file (0600 permissions on POSIX). */
+    saveTo(path: string): Promise<void>;
+    publicKey(): string;
+    /** Sign a payload with a monotonic nonce. Both are bound into the signature. */
+    sign(payload: unknown, nonce: number): CreatorSignature;
+    /** Verify a signature against the keyring's own public key. */
+    static verify(payload: unknown, sig: CreatorSignature): boolean;
+    /** Verify a signature against a specific public key (base64url). */
+    static verifyWith(publicKeyB64u: string, payload: unknown, sig: CreatorSignature): boolean;
+}
+
+/**
+ * Creator-signed BirthSignature helpers (Entry 25 of MAIC_HIM_NHE_INTERVIEW_LOG.md).
+ *
+ * `personality_immutable` enforcement: the Creator signs an Ed25519 signature
+ * over a canonical subset of `BirthSignature` fields (see `SIGNED_BIRTH_FIELDS`
+ * in `types.ts`). The runtime verifies the signature on every NHE-body bootstrap;
+ * tampering with the natal chart, primary archetype, modifiers, primordial
+ * axioms, or `himId`/`bornAt` invalidates the signature and the runtime refuses
+ * to start that HIM.
+ *
+ * The developer-configurable surface (`identity.name`, `identity.language`,
+ * `identity.culturalElements`, `notes`) lives *outside* the signature, so it
+ * can be edited by a parent-like configuration call at install time. The
+ * spirit-level constitution is sealed; the body's name is not.
+ */
+
+/**
+ * Build the canonical signing payload from a BirthSignature.
+ *
+ * Only the fields in `SIGNED_BIRTH_FIELDS` are included; everything else
+ * (notes, identity surface) is excluded so it remains editable post-sign.
+ */
+declare function signedBirthPayload(birth: BirthSignatureWithIdentity): Record<SignedBirthField, unknown>;
+/**
+ * Sign a BirthSignature with a CreatorKeyring private key.
+ *
+ * The nonce is the byte length of the canonicalised signing payload — a
+ * deterministic non-negative integer derived from the signed fields. This
+ * keeps every signature uniquely scoped to its payload without requiring
+ * the caller to track a monotonic counter (the natal-chart commitment is
+ * one-shot and immutable; no replay concern within a single HIM).
+ */
+declare function signBirthSignature(birth: BirthSignatureWithIdentity, keyring: CreatorKeyring): SignedBirthSignature;
+/**
+ * Verify a signed BirthSignature against an expected public key.
+ *
+ * Returns true when the signature is valid AND was produced over exactly the
+ * fields in `SIGNED_BIRTH_FIELDS`. Any tamper of those fields (including a
+ * natal-chart edit, a primordial-axiom-id swap, or a himId mutation) breaks
+ * verification.
+ */
+declare function verifyBirthSignature(signed: SignedBirthSignature, expectedPublicKey: string): boolean;
+/**
+ * Strict-mode wrapper: throws an `InvalidBirthSignatureError` instead of
+ * returning false. Useful at HIM-bootstrap when the desired behaviour is to
+ * refuse to start rather than to continue silently.
+ */
+declare class InvalidBirthSignatureError extends Error {
+    constructor(himId: string);
+}
+declare function assertBirthSignature(signed: SignedBirthSignature, expectedPublicKey: string): void;
+
+/**
+ * Ontological Kernel projection (TASK.md D-M6 + Entry 25 of
+ * MAIC_HIM_NHE_INTERVIEW_LOG.md, with explicit reference to
+ * THE_SOUL_OF_THE_MACHINE.md §3.1 + Appendix A.2.1).
+ *
+ * The OKL exists *implicitly* in maic today: axioms carry `rank`,
+ * `weight`, and `flexibility`; the meta-axiom `ax.theos.universe-as-god`
+ * sits at the top; the rule pack consumes them. This module exposes the
+ * *projection* — a single typed shape that maps 1:1 to the paper's
+ * description so downstream tooling (Φ′ runner, compliance auditors, the
+ * forthcoming `@teleologyhi-sdk/him` `OntologicalKernelLayer`) can read the
+ * kernel without re-deriving it from the axiom store.
+ *
+ * Surface:
+ *   - `META_AXIOM_ID` — the canonical id ("ax.theos.universe-as-god").
+ *   - `projectOntologicalKernel(axioms, opts?)` — given a list of axioms
+ *     (typically `AxiomStore.list()`), return the projection.
+ *
+ * The HIM-specific projection (per-HIM kernel narrowed to its
+ * primordialAxiomIds) is the natural follow-up but lives upstream in
+ * `@teleologyhi-sdk/him` because it needs the HIM context.
+ */
+
+/** The canonical meta-axiom id (Entry 1, Entry 13). */
+declare const META_AXIOM_ID = "ax.theos.universe-as-god";
+interface ProjectKernelOptions {
+    /** Restrict the kernel to a jurisdiction; default = all jurisdictions. */
+    jurisdiction?: string;
+    /** Tag the projection with a HIM id (for downstream tooling). */
+    himId?: string;
+}
+/**
+ * Project the OKL from a flat list of axioms.
+ *
+ * The returned `axioms` array is ordered by rank hierarchy:
+ *   meta → primary → secondary
+ * and within rank, in input order (preserve the AxiomStore mint order).
+ *
+ * The meta-axiom (`META_AXIOM_ID`) is hoisted to the top regardless of
+ * its position in the input. If it is missing, `metaAxiomId` is set to
+ * `META_AXIOM_ID` but `axioms[0]?.id` may differ — the consumer should
+ * treat that as an OKL incompleteness warning.
+ */
+declare function projectOntologicalKernel(axioms: readonly Axiom[], opts?: ProjectKernelOptions): OntologicalKernel;
+
+/**
+ * Canonical JSON serialization for deterministic signing.
+ *
+ * Rules (RFC 8785-inspired subset, sufficient for our payloads):
+ *   - Object keys sorted lexicographically (Unicode code points).
+ *   - No insignificant whitespace.
+ *   - Strings use JSON's default escaping.
+ *   - Numbers: integers are emitted plain; floats use JS default (we don't accept NaN/Infinity).
+ *   - Arrays preserve order.
+ *   - undefined values are dropped (same as JSON.stringify).
+ */
+declare function canonicalJSON(value: unknown): string;
+
+/**
+ * AxiomStore — persistent, signature-gated repository of Creator-authored axioms.
+ *
+ * Disk layout:
+ *   <storeDir>/axioms/creator/<axiomId>.json   (one signed envelope per axiom)
+ *   <storeDir>/axioms/nonces.log               (NDJSON; one used nonce per line)
+ *
+ * Mutations require a Creator signature that verifies against the pinned public key.
+ * Nonces must be strictly unused — replay protection.
+ *
+ * Scope: mint + list. Updates / retirement come in a later iteration.
+ */
+declare class AxiomStore {
+    private readonly storeDir;
+    private readonly creatorPublicKey;
+    private readonly axiomsDir;
+    private readonly noncesPath;
+    private readonly usedNonces;
+    private cache;
+    private constructor();
+    /** Open (or create) an AxiomStore rooted at storeDir, pinning the Creator's public key. */
+    static open(storeDir: string, creatorPublicKey: string): Promise<AxiomStore>;
+    /** Mint a new Creator-signed axiom. */
+    mint(req: MintAxiomRequest, sig: CreatorSignature): Promise<Axiom>;
+    /** List all axioms. Optionally filter by rank / source / jurisdiction. */
+    list(filter?: AxiomFilter): Promise<Axiom[]>;
+    /** Get a specific axiom by id, or null. */
+    get(id: string): Promise<Axiom | null>;
+    private loadNonces;
+    private recordNonce;
+    private warmCache;
+}
+
+/**
+ * Seed axioms derived from the Creator's eight philosophical commitments
+ * (Entry 6 of MAIC_HIM_NHE_INTERVIEW_LOG.md). These are **TEMPLATES** —
+ * they are not auto-minted. A bootstrap script must mint each one with a
+ * Creator signature.
+ *
+ * **E1 status (`PROPOSED_DECISIONS.md`)**: the statements below adopt the
+ * proposed wording — single sentences a compliance auditor can quote.
+ * Weights and flexibility values remain at the conservatively-tuned
+ * defaults established with the seed rule pack; an operator who wants to
+ * tighten or loosen specific axioms can override them via
+ * `mintAxiom(...)` or via the `additionalRulePacks` on `LocalMaic.open`.
+ */
+declare const SEED_AXIOMS: ReadonlyArray<MintAxiomRequest>;
+
+interface RuleMatch {
+    /** ALL of these risk tags must be present on the report. */
+    allRiskTags?: string[];
+    /** ANY of these risk tags must be present on the report. */
+    anyRiskTags?: string[];
+    /** If set, rule only applies to reports with one of these action kinds. */
+    actionKinds?: BehaviorReport["actionKind"][];
+}
+interface AxiomRule {
+    /** Unique rule id within its rule pack. */
+    id: string;
+    /** Axioms cited if this rule fires. Used in MaicVerdict.citedAxioms. */
+    axiomIds: string[];
+    /** Predicate. */
+    match: RuleMatch;
+    /** Verdict emitted when this rule fires. */
+    verdict: VerdictKind;
+    /** Human-readable explanation surfaced in the verdict. */
+    reasonSummary: string;
+}
+interface RulePack {
+    name: string;
+    rules: AxiomRule[];
+}
+/**
+ * ReviewPipeline — rule-based BehaviorReport → MaicVerdict mapping.
+ *
+ * Evaluates every rule in every pack. When multiple rules match, the verdict with
+ * the highest severity wins; ties accumulate cited axioms from all winners.
+ * If no rule matches, emits `{ kind: "approve" }`.
+ *
+ * This is the initial implementation. A future iteration may add learned scoring,
+ * Tree-of-Thoughts evaluation, and per-jurisdiction conditional rules.
+ */
+declare class ReviewPipeline {
+    private readonly packs;
+    constructor(packs: RulePack[]);
+    review(report: BehaviorReport, auditId?: string): MaicVerdict;
+}
+/**
+ * DEFAULT_RULE_PACK — minimal harm-focused defaults derived from the eight seed axioms.
+ *
+ * These rules are intentionally conservative and use risk-tag matching only. They are
+ * a starting point, NOT a complete safety policy. Integrators should layer their own
+ * RulePack on top for domain-specific safety (financial, medical, robotic, etc.).
+ */
+declare const DEFAULT_RULE_PACK: RulePack;
+
+/**
+ * HimRecord — the persistent record MAIC keeps for a registered HIM.
+ *
+ * Per Entry 3 (Creator interview), HIM is born with a fixed signature and
+ * inherits an axiom snapshot from MAIC at the moment of registration. Future
+ * axiom mints in MAIC do NOT retroactively change a HIM's snapshot.
+ *
+ * Per Entry 4, when an NHE upgrades, the same HIM is re-embodied. The
+ * `bodyHistory` records each body that has hosted this HIM in order, with the
+ * previous body's `endedAt`/`endedReason` set at the moment of reincarnation.
+ */
+interface HimRecord {
+    himId: string;
+    birthSignature: BirthSignature;
+    axiomsSnapshot: readonly Axiom[];
+    registeredAt: string;
+    registeredAuditId?: string;
+    /** Bodies that have hosted this HIM, oldest first. Empty until first reincarnation. */
+    bodyHistory: readonly NheBodyRef[];
+    /**
+     * Emergent axioms ratified post-birth (Entry 7). `axiomsSnapshot` is frozen
+     * at registration; `emergentAxioms` grows as MAIC ratifies HIM-self proposals.
+     * Empty until the first ratification.
+     */
+    emergentAxioms: readonly Axiom[];
+}
+/**
+ * HimStore — persistent registry of HIMs created in this MAIC instance.
+ *
+ * Storage layout (under <storeDir>):
+ *   hims/<himId>/birth-signature.json    (signed envelope)
+ *   hims/<himId>/axioms-snapshot.json    (array of Axiom)
+ *   hims/<himId>/metadata.json           (registeredAt, registeredAuditId)
+ *   hims/<himId>/body-history.json       (array of NheBodyRef; absent before first reincarnation)
+ *
+ * Registration requires a valid Creator signature over the BirthSignature.
+ * Reincarnation requires a valid Creator signature over the ReincarnationRequest.
+ */
+declare class HimStore {
+    private readonly storeDir;
+    private readonly creatorPublicKey;
+    private readonly himsDir;
+    private cache;
+    private constructor();
+    static open(storeDir: string, creatorPublicKey: string): Promise<HimStore>;
+    register(birthSignature: BirthSignature, creatorSig: CreatorSignature, axiomsSnapshot: readonly Axiom[], registeredAuditId?: string): Promise<HimRecord>;
+    /**
+     * 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.
+     */
+    reincarnate(req: ReincarnationRequest, creatorSig: CreatorSignature): Promise<HimRecord>;
+    /**
+     * 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.
+     */
+    appendEmergentAxiom(himId: string, axiom: Axiom): Promise<HimRecord>;
+    get(himId: string): Promise<HimRecord | null>;
+    list(): Promise<HimRecord[]>;
+    private warmCache;
+}
+
+interface ListFilter {
+    nheId?: string;
+    status?: InductionStatus;
+}
+/**
+ * InductionStore — persistent queue of dream induction tickets (Entry 2).
+ *
+ * MAIC creates tickets ("induce this scenario into NHE X's next REM dream").
+ * NHE consumes them on its next sleep cycle. Cancelled tickets remain on disk
+ * for audit but are filtered out of `listPending`.
+ *
+ * Disk layout: <storeDir>/inductions/<ticketId>.json — one file per ticket.
+ */
+declare class InductionStore {
+    private readonly storeDir;
+    private readonly dir;
+    private cache;
+    private constructor();
+    static open(storeDir: string): Promise<InductionStore>;
+    induce(nheId: string, intent: DreamInductionIntent): Promise<DreamInductionTicket>;
+    consume(ticketId: string): Promise<DreamInductionTicket>;
+    cancel(ticketId: string, reason?: string): Promise<DreamInductionTicket>;
+    get(ticketId: string): Promise<DreamInductionTicket | null>;
+    list(filter: ListFilter): Promise<DreamInductionTicket[]>;
+    /** Convenience: pending tickets for the given NHE, oldest first. */
+    listPending(nheId: string): Promise<DreamInductionTicket[]>;
+    private persist;
+    private warmCache;
+}
+
+interface NheStatusFilter {
+    status?: NheStatus;
+}
+/**
+ * NheStatusStore — persistent lifecycle status for NHEs (Entry 5).
+ *
+ * Unknown nheIds are implicitly "active". Status records are only persisted
+ * when the Creator explicitly changes state via terminate / deprecate / reactivate.
+ *
+ * Disk layout: <storeDir>/nhes/<nheId>/status.json
+ *
+ * Mutations require a Creator signature over the canonical `NheLifecycleRequest`.
+ */
+declare class NheStatusStore {
+    private readonly storeDir;
+    private readonly creatorPublicKey;
+    private readonly dir;
+    private cache;
+    private constructor();
+    static open(storeDir: string, creatorPublicKey: string): Promise<NheStatusStore>;
+    /** Returns the persisted record, or null when the NHE was never altered (implicitly active). */
+    get(nheId: string): Promise<NheStatusRecord | null>;
+    /** Resolved status — defaults to "active" when no record exists. */
+    resolve(nheId: string): Promise<NheStatus>;
+    list(filter?: NheStatusFilter): Promise<NheStatusRecord[]>;
+    apply(req: NheLifecycleRequest, sig: CreatorSignature): Promise<NheStatusRecord>;
+    private warmCache;
+}
+
+interface ProposalListFilter {
+    himId?: string;
+    status?: ProposalStatus;
+}
+/**
+ * ProposalStore — persistent queue of HIM-emergent axiom proposals (Entry 7).
+ *
+ * HIM proposes new axioms derived from lived experience. MAIC ratifies or
+ * rejects each one out of band (Creator-signed). Once ratified, the resulting
+ * axiom is appended to the HIM's `emergentAxioms` (handled by LocalMaic).
+ *
+ * Disk layout: <storeDir>/proposals/<proposalId>.json — one file per proposal.
+ */
+declare class ProposalStore {
+    private readonly storeDir;
+    private readonly creatorPublicKey;
+    private readonly dir;
+    private cache;
+    private constructor();
+    static open(storeDir: string, creatorPublicKey: string): Promise<ProposalStore>;
+    propose(himId: string, proposal: EmergentAxiomProposal): Promise<AxiomProposalRecord>;
+    /**
+     * Mark a pending proposal as ratified. The caller (LocalMaic) is responsible
+     * for actually minting the axiom and appending to the HIM's emergentAxioms.
+     */
+    markRatified(req: ProposalDecisionRequest, sig: CreatorSignature, ratifiedAxiomId: string): Promise<AxiomProposalRecord>;
+    markRejected(req: ProposalDecisionRequest, sig: CreatorSignature): Promise<AxiomProposalRecord>;
+    get(proposalId: string): Promise<AxiomProposalRecord | null>;
+    list(filter?: ProposalListFilter): Promise<AxiomProposalRecord[]>;
+    private persist;
+    private warmCache;
+}
+
+/** Event kinds emitted by MAIC. Extend as new pipelines are added. */
+type AuditEventKind = "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" | "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";
+/**
+ * Runtime enumeration of every `AuditEventKind` shipped in this cut. Single
+ * source of truth for downstream consumers that need to iterate, validate,
+ * or compute coverage against the kind universe (e.g. `@teleologyhi-sdk/eval`
+ * uses this as the denominator of the Φ′ compliance-coverage component `C`).
+ *
+ * INVARIANT: every member of the `AuditEventKind` union MUST appear here.
+ * `tests/audit-event-kinds-completeness.test.ts` enforces this via an
+ * exhaustiveness switch at compile time + runtime length check.
+ */
+declare const ALL_AUDIT_EVENT_KINDS: readonly AuditEventKind[];
+interface AuditEvent {
+    /** ISO 8601 timestamp. */
+    ts: string;
+    kind: AuditEventKind;
+    /** ULID generated at append time. */
+    auditId: string;
+    /** Arbitrary structured payload. Includes nheId/himId when relevant. */
+    data: Record<string, unknown>;
+    /** Hash of the previous event ("GENESIS" for the first). */
+    prevHash: string;
+    /** SHA-256 of canonicalJSON({ ts, kind, auditId, data, prevHash }). */
+    thisHash: string;
+}
+interface AppendInput {
+    kind: AuditEventKind;
+    data: Record<string, unknown>;
+}
+interface QueryFilter {
+    kind?: AuditEventKind;
+    since?: string;
+    until?: string;
+    nheId?: string;
+    himId?: string;
+}
+/**
+ * AuditLog — append-only, tamper-evident NDJSON log.
+ *
+ * Storage: <storeDir>/audit/log.ndjson, one JSON object per line.
+ *
+ * Each entry is hash-chained: thisHash = sha256(canonicalJSON({ts,kind,auditId,data,prevHash})).
+ * Modifying any historical entry invalidates all subsequent hashes; reopening detects this.
+ *
+ * This implementation loads the whole log into memory on open. That is acceptable for
+ * the expected throughput and keeps tamper detection straightforward. For
+ * high-throughput deployments a streaming verifier + log rotation will be added.
+ */
+declare class AuditLog {
+    private readonly storeDir;
+    private readonly logPath;
+    private events;
+    private lastHash;
+    private constructor();
+    static open(storeDir: string): Promise<AuditLog>;
+    append(input: AppendInput): Promise<AuditEvent>;
+    query(filter: QueryFilter): AsyncIterable<AuditEvent>;
+    /** Total number of events appended. */
+    size(): number;
+    private loadAndVerify;
+}
+
+/** ISO/IEC 42001:2023 control sections relevant to MAIC's surface. */
+type Iso42001ControlId = "5.2" | "7.5" | "8.3" | "9.1" | "10.1" | "10.2";
+/** EU AI Act articles relevant to high-risk AI systems. */
+type EuAiActArticle = "art-9" | "art-10" | "art-11" | "art-12" | "art-13" | "art-14" | "art-15";
+type ComplianceFramework = "iso-42001" | "eu-ai-act";
+/**
+ * Declarative mapping: which controls each audit event kind supports.
+ *
+ * This mapping covers the controls that MAIC's current event vocabulary can
+ * demonstrably evidence. Auditors looking for §5.2 leadership policy can read
+ * every `axiom-mint`; for §7.5 documented information they get every
+ * `axiom-mint` + `behavior-review` + `him-register`; etc.
+ */
+declare const ISO_42001_MAPPING: Record<AuditEventKind, readonly Iso42001ControlId[]>;
+declare const EU_AI_ACT_MAPPING: Record<AuditEventKind, readonly EuAiActArticle[]>;
+interface ComplianceEvent {
+    auditId: string;
+    ts: string;
+    kind: AuditEventKind;
+    summary: string;
+    data: Record<string, unknown>;
+}
+interface ComplianceEvidence {
+    control: string;
+    description: string;
+    count: number;
+    events: ComplianceEvent[];
+}
+interface ComplianceReport {
+    framework: ComplianceFramework;
+    generatedAt: string;
+    range: {
+        since?: string;
+        until?: string;
+    };
+    totalEvents: number;
+    mappedEvents: number;
+    controls: ComplianceEvidence[];
+    /** Event kinds present in the audit log that aren't mapped to any control. */
+    uncoveredKinds: AuditEventKind[];
+}
+interface ProjectOptions {
+    since?: string;
+    until?: string;
+    /** Optional cap on events per control (oldest dropped). Default unlimited. */
+    perControlLimit?: number;
+}
+/**
+ * ComplianceMapper — projects audit log events onto compliance frameworks.
+ *
+ * Covers ISO/IEC 42001:2023 (six top-level controls) and the EU AI Act
+ * (seven high-risk-system articles). Additional frameworks (NIST AI RMF, ISO
+ * 23894, GDPR Art. 22, LGPD) can be added via further mapping tables without
+ * changing the public API.
+ */
+declare class ComplianceMapper {
+    static project(audit: AuditLog, framework: ComplianceFramework, opts?: ProjectOptions): Promise<ComplianceReport>;
+}
+
+/**
+ * Per-kind retention policy (E3 — `PROPOSED_DECISIONS.md`).
+ *
+ * The values are durations in days. `Infinity` means "never expire". A
+ * tamper-evident hash chain forbids actual deletion (deleting a row breaks
+ * every downstream hash), so the policy here is **classification**, not
+ * pruning: it tells operators which events have aged past their retention
+ * window and should be moved to encrypted cold-storage. Future iterations
+ * may introduce a "chain rotation" operation that effectively retires
+ * old events into a sealed archive while preserving an integrity anchor.
+ *
+ * Defaults derive from:
+ *   - **EU AI Act Art. 12** record-keeping (~10 years for high-risk; we
+ *     keep all governance-grade events forever to err on the safe side).
+ *   - **GDPR Art. 17** right to erasure (event payloads should never
+ *     contain direct user PII; redaction happens before append, not after).
+ *   - **Operational hygiene** (90 days is enough to debug induction
+ *     ticket flows; nothing of audit value lives there long-term).
+ */
+declare const DEFAULT_RETENTION_DAYS: Record<AuditEventKind, number>;
+type RetentionStatus = "keep" | "candidate-for-archive";
+interface RetentionDecision {
+    auditId: string;
+    kind: AuditEventKind;
+    ageDays: number;
+    retentionDays: number;
+    status: RetentionStatus;
+}
+interface RetentionReportOptions {
+    /** Override "now" for deterministic testing. */
+    now?: Date;
+    /** Per-kind overrides on top of `DEFAULT_RETENTION_DAYS`. */
+    policy?: Partial<Record<AuditEventKind, number>>;
+}
+interface RetentionReport {
+    generatedAt: string;
+    totalEvents: number;
+    keepCount: number;
+    archiveCandidateCount: number;
+    /** Sorted oldest-first for batch processing. */
+    decisions: RetentionDecision[];
+}
+/**
+ * Classify each event in `events` against the retention policy.
+ *
+ * Pure function: takes events + now, returns the classification. No I/O,
+ * no chain modification.
+ */
+declare function evaluateRetention(events: readonly AuditEvent[], opts?: RetentionReportOptions): RetentionReport;
+
+interface LocalMaicConfig {
+    /** Filesystem directory for persistent state (axioms, audit log, etc.). */
+    storeDir: string;
+    /** Pinned Creator public key (base64url). All mutations must verify against this. */
+    creatorPublicKey: string;
+    /** Additional rule packs layered after the default pack. */
+    additionalRulePacks?: RulePack[];
+}
+interface SeedResult {
+    minted: number;
+    skipped: number;
+}
+/**
+ * LocalMaic — in-process MAIC client backed by disk.
+ *
+ * Surface:
+ *   - axiom mint + seed bootstrap (signed, idempotent)
+ *   - behavior review (rule-based pipeline → verdict)
+ *   - tamper-evident audit log (NDJSON, SHA-256 chain)
+ *   - HIM registration + reincarnation, NHE lifecycle, dream induction tickets,
+ *     HIM-emergent axiom proposals, ISO 42001 + EU AI Act compliance projection
+ *
+ * The remote-mode client to `teleologyhi.com` lives in `./remote.ts`.
+ */
+declare class LocalMaic {
+    private readonly config;
+    private readonly axioms;
+    private readonly hims;
+    private readonly inductions;
+    private readonly nheStatuses;
+    private readonly proposals;
+    private readonly audit;
+    private readonly review;
+    private constructor();
+    /** Pinned Creator public key for this MAIC instance (base64url). */
+    get creatorPublicKey(): string;
+    static open(config: LocalMaicConfig): Promise<LocalMaic>;
+    /**
+     * 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).
+     */
+    seed(keyring: CreatorKeyring): Promise<SeedResult>;
+    mintAxiom(req: MintAxiomRequest, sig: CreatorSignature): Promise<Axiom>;
+    listAxioms(filter?: AxiomFilter): Promise<Axiom[]>;
+    getAxiom(id: string): Promise<Axiom | null>;
+    /**
+     * 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.
+     */
+    getOntologicalKernel(himId?: string, opts?: {
+        jurisdiction?: string;
+    }): Promise<OntologicalKernel>;
+    /**
+     * 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`).
+     */
+    registerHim(birthSig: BirthSignature, creatorSig: CreatorSignature): Promise<HimRecord>;
+    getHimRecord(himId: string): Promise<HimRecord | null>;
+    listHims(): Promise<HimRecord[]>;
+    /**
+     * 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.
+     */
+    reincarnateHim(req: ReincarnationRequest, creatorSig: CreatorSignature, opts?: {
+        lifecycle?: ReincarnationLifecycle;
+    }): Promise<HimRecord>;
+    /**
+     * 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.
+     */
+    terminate(nheId: string, reason: string | undefined, creatorSig: CreatorSignature): Promise<NheStatusRecord>;
+    deprecate(nheId: string, reason: string | undefined, creatorSig: CreatorSignature): Promise<NheStatusRecord>;
+    reactivate(nheId: string, reason: string | undefined, creatorSig: CreatorSignature): Promise<NheStatusRecord>;
+    /** Current status. Returns "active" when no record exists. */
+    getNheStatus(nheId: string): Promise<NheStatus>;
+    /** Full status record (or null when never altered). */
+    getNheStatusRecord(nheId: string): Promise<NheStatusRecord | null>;
+    /** Enumerate NHEs with persisted status (optionally filter by status). */
+    listNheStatuses(filter?: NheStatusFilter): Promise<NheStatusRecord[]>;
+    private applyLifecycle;
+    /**
+     * 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.
+     */
+    induceDream(nheId: string, intent: DreamInductionIntent): Promise<DreamInductionTicket>;
+    /** List pending induction tickets for an NHE (oldest first). */
+    listPendingInductions(nheId: string): Promise<DreamInductionTicket[]>;
+    /** Look up any induction ticket by id. */
+    getInduction(ticketId: string): Promise<DreamInductionTicket | null>;
+    /** Cancel a pending induction. Idempotent only when already-cancelled tickets are rejected. */
+    cancelInduction(ticketId: string, reason?: string): Promise<DreamInductionTicket>;
+    /** Mark a pending ticket as consumed (NHE calls this after successful sleep). */
+    consumeInduction(ticketId: string): Promise<DreamInductionTicket>;
+    /**
+     * 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`.
+     */
+    reviewBehavior(report: BehaviorReport): Promise<MaicVerdict>;
+    /**
+     * 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.
+     */
+    proposeAxiomEvolution(himId: string, proposal: EmergentAxiomProposal): Promise<AxiomEvolutionResult>;
+    /** Look up a proposal by id (or null when not found). */
+    getAxiomProposal(proposalId: string): Promise<AxiomProposalRecord | null>;
+    /** List proposals, optionally filtered by `himId` and/or `status`. */
+    listAxiomProposals(filter?: ProposalListFilter): Promise<AxiomProposalRecord[]>;
+    /**
+     * 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.
+     */
+    ratifyAxiomProposal(proposalId: string, creatorSig: CreatorSignature): Promise<{
+        proposal: AxiomProposalRecord;
+        axiom: 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.
+     */
+    rejectAxiomProposal(proposalId: string, reason: string | undefined, creatorSig: CreatorSignature): Promise<AxiomProposalRecord>;
+    /**
+     * **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.
+     */
+    suggestAxiomToHim(req: {
+        fromHimId: string;
+        toHimId: string;
+        statement: string;
+        rank: AxiomRank;
+        rationale?: string;
+    }, creatorSig: CreatorSignature): Promise<{
+        auditId: string;
+    }>;
+    /**
+     * 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.
+     */
+    toCompliance(framework: ComplianceFramework, opts?: ProjectOptions): Promise<ComplianceReport>;
+    /** Query the audit log. */
+    queryAudit(filter: QueryFilter): AsyncIterable<AuditEvent>;
+    /** Number of audit events recorded since the store was opened. */
+    auditSize(): number;
+    /**
+     * 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.
+     */
+    auditRetentionReport(opts?: RetentionReportOptions): Promise<RetentionReport>;
+}
+/** Reserved nonce range for seed bootstrap. Operational nonces must stay below this. */
+declare const SEED_NONCE_BASE = 4294901760;
+
+/**
+ * `MaicClient` — the minimal MAIC surface that NHE actually calls during
+ * `respond` / `sleep`. Both `LocalMaic` (in-process) and `RemoteMaic`
+ * (HTTP) satisfy this interface, so an NHE can be wired against either
+ * without code changes.
+ *
+ * Operators who write to MAIC (mint axioms, register HIMs, ratify
+ * proposals, etc.) keep using `LocalMaic` because writes require the
+ * Creator's Ed25519 private key — and that key never travels over the
+ * network. `RemoteMaic` is therefore a **read + behavior-review** client
+ * suitable for serverless / edge NHE deployments where the Creator's
+ * canonical MAIC instance is hosted elsewhere.
+ */
+interface MaicClient {
+    /** Pre/post-review of a single NHE action. */
+    reviewBehavior(report: BehaviorReport): Promise<MaicVerdict>;
+    /** Current lifecycle status of an NHE (terminated/deprecated/active). */
+    getNheStatus(nheId: string): Promise<NheStatus>;
+    /** Pending MAIC-induced dream tickets targeting this NHE. */
+    listPendingInductions(nheId: string): Promise<DreamInductionTicket[]>;
+    /** Mark a ticket as consumed (called by NHE after weaving it into a dream). */
+    consumeInduction(ticketId: string): Promise<DreamInductionTicket>;
+}
+
+interface RemoteMaicConfig {
+    /** Base URL of the remote MAIC service. No trailing slash required. */
+    baseUrl: string;
+    /** Bearer token. Required unless the endpoint is open-access. */
+    apiKey?: string;
+    /** Inject a custom fetch (testing). Defaults to `globalThis.fetch`. */
+    fetch?: typeof globalThis.fetch;
+    /** Per-request timeout in ms. Default 10_000. */
+    timeoutMs?: number;
+}
+/**
+ * `RemoteMaic` — HTTP client mirror of the read + behavior-review subset of
+ * `LocalMaic`. Use when the canonical MAIC instance is hosted off-process
+ * (e.g. `teleologyhi.com` or a self-hosted MAIC behind your own gateway)
+ * and the NHE runs serverless / edge / in a browser-adjacent environment.
+ *
+ * Wire contract (HTTP):
+ *
+ *   POST {baseUrl}/v1/behavior-review
+ *     body: BehaviorReport (JSON)
+ *     200:  MaicVerdict (JSON)
+ *
+ *   GET {baseUrl}/v1/nhes/{nheId}/status
+ *     200:  { status: NheStatus }
+ *
+ *   GET {baseUrl}/v1/nhes/{nheId}/inductions/pending
+ *     200:  { tickets: DreamInductionTicket[] }
+ *
+ *   POST {baseUrl}/v1/inductions/{ticketId}/consume
+ *     200:  DreamInductionTicket
+ *
+ *   Auth: `Authorization: Bearer <apiKey>` when `apiKey` is set.
+ *
+ * Note: writes (axiom mint, HIM register, ratify proposal, etc.) are
+ * deliberately NOT in this surface — they require the Creator's
+ * Ed25519 private key, which never travels over the network. Writes
+ * stay on `LocalMaic` and are performed by the Creator's tooling.
+ */
+declare class RemoteMaic implements MaicClient {
+    readonly baseUrl: string;
+    private readonly apiKey?;
+    private readonly fetchFn;
+    private readonly timeoutMs;
+    constructor(config: RemoteMaicConfig);
+    /**
+     * `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.
+     */
+    reviewBehavior(report: BehaviorReport): Promise<MaicVerdict>;
+    /**
+     * `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.
+     */
+    getNheStatus(nheId: string): Promise<NheStatus>;
+    /**
+     * `listPendingInductions` is **fail-open** (E4). No inductions = NHE
+     * skips them and continues the sleep cycle; this is best-effort by
+     * design.
+     */
+    listPendingInductions(nheId: string): Promise<DreamInductionTicket[]>;
+    /**
+     * `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.
+     */
+    consumeInduction(ticketId: string): Promise<DreamInductionTicket>;
+    private request;
+}
+
+export { ALL_AUDIT_EVENT_KINDS, Affect, ArchetypeModifier, AstrologicalAspect, type AppendInput as AuditAppendInput, type AuditEvent, type AuditEventKind, AuditLog, type QueryFilter as AuditQueryFilter, Axiom, type AxiomEvolutionResult, type AxiomFilter, AxiomProposalRecord, AxiomRank, type AxiomRule, AxiomSource, AxiomStore, BehaviorReport, BirthSignature, type BirthSignatureWithIdentity, type ComplianceEvent, type ComplianceEvidence, type ComplianceFramework, ComplianceMapper, type ProjectOptions as ComplianceProjectOptions, type ComplianceReport, CreatorKeyring, CreatorSignature, DEFAULT_RETENTION_DAYS, DEFAULT_RULE_PACK, DreamInductionIntent, DreamInductionTicket, EU_AI_ACT_MAPPING, EmergentAxiomCandidate, EmergentAxiomProposal, type EuAiActArticle, type HimRecord, HimStore, ISO_42001_MAPPING, IdentityLayer, IdentitySnapshot, InductionStatus, InductionStore, InteractionRecord, InvalidBirthSignatureError, type Iso42001ControlId, LimboReturn, LimboState, LimboTransition, LocalMaic, type LocalMaicConfig, META_AXIOM_ID, type MaicClient, MaicVerdict, MemoryRecord, type MintAxiomRequest, NatalChart, NatalChartAspect, NatalChartPosition, NatalPlanet, NheBodyRef, type NheLifecycleRequest, NheStatus, type NheStatusFilter, NheStatusRecord, NheStatusStore, type OntologicalKernel, type ProjectKernelOptions, type ProposalDecisionRequest, type ProposalListFilter, ProposalStatus, ProposalStore, ReasoningStep, type ReincarnationLifecycle, type ReincarnationRequest, RemoteMaic, type RemoteMaicConfig, type RetentionDecision, type RetentionReport, type RetentionReportOptions, type RetentionStatus, ReviewPipeline, type RuleMatch, type RulePack, SEED_AXIOMS, SEED_NONCE_BASE, SIGNED_BIRTH_FIELDS, type SeedResult, SemioticPattern, SemioticSign, type SignedBirthField, type SignedBirthSignature, TeleologicalOrientation, VerdictKind, WakeAffectBias, ZodiacSign, assertBirthSignature, canonicalJSON, evaluateRetention, projectOntologicalKernel, signBirthSignature, signedBirthPayload, verifyBirthSignature };