@neuroverseos/governance 0.6.0 → 0.7.0

package/dist/radiant/index.d.ts

@@ -0,0 +1,1301 @@
+/**
+ * @neuroverseos/governance/radiant — core types
+ *
+ * Encodes the Universal Math frame from radiant/PROJECT-PLAN.md:
+ *
+ *   - Asymmetric Life/Cyber capability spaces (two distinct native dimension sets,
+ *     never mirrored).
+ *   - Presence-based averaging — no weights, no coefficients.
+ *   - N (coherence) requires a loaded worldmodel; UNAVAILABLE otherwise.
+ *   - INSUFFICIENT_EVIDENCE and UNAVAILABLE are first-class sentinel states.
+ *     Silence is never scored as neutral.
+ *
+ * Conceptually: NeuroverseOS is the universe the two gyroscopes exist in.
+ * It defines how they can behave and how they can survive. These types
+ * describe what the gyroscopes look like when measured from inside that
+ * universe.
+ */
+/**
+ * Deterministic presence rule. A dimension or bridging component is
+ * considered present iff event_count >= k AND confidence >= c.
+ *
+ * Tunable per worldmodel via frontmatter. Not per-call — tuning belongs to
+ * the constitution, not to the invocation.
+ */
+interface EvidenceGate {
+    /** Minimum event count in the measurement window. */
+    k: number;
+    /** Minimum signal extraction confidence (0–1). */
+    c: number;
+}
+/** Default gate: k=3 events, c=0.5 confidence. Overridable per worldmodel. */
+declare const DEFAULT_EVIDENCE_GATE: EvidenceGate;
+/**
+ * Any item that carries a 0–100 score, an event count, and a 0–1 confidence.
+ * `presenceAverage` operates on arrays of this shape, regardless of the
+ * domain-specific identity each item carries.
+ */
+interface ScoredObservation {
+    score: number;
+    eventCount: number;
+    confidence: number;
+}
+/**
+ * A single observed life-native capability dimension. Defaults declared by
+ * the NeuroVerse base worldmodel: Cognition, Creativity, Sensory. A per-org
+ * worldmodel can declare more or fewer.
+ */
+interface LifeDimension extends ScoredObservation {
+    id: string;
+}
+/**
+ * The life gyroscope's measured state across its native dimensions.
+ */
+interface LifeCapability {
+    dimensions: LifeDimension[];
+}
+/**
+ * A single observed cyber-native capability dimension. Defaults declared by
+ * the NeuroVerse base worldmodel: AI-reasoning, AR/adaptivity, Spatial.
+ *
+ * CyberDimension is a distinct type from LifeDimension — the two gyroscopes
+ * have independent native vocabularies and must not be mixed at the type
+ * level.
+ */
+interface CyberDimension extends ScoredObservation {
+    id: string;
+}
+/**
+ * The cyber gyroscope's measured state across its native dimensions.
+ */
+interface CyberCapability {
+    dimensions: CyberDimension[];
+}
+/**
+ * The four components of NeuroVerse coherence. Each measures a different
+ * kind of translation through an open corridor:
+ *
+ *   ALIGN        — both sides point at the same mission via shared worldmodel refs
+ *   HANDOFF      — life-side output is legibly picked up by cyber-side (or vice versa)
+ *   CO_DECISION  — both intelligences contributed interpretable input to a decision
+ *   CO_EXECUTION — both intelligences are present in a shipped artifact
+ */
+type BridgingComponent = 'ALIGN' | 'HANDOFF' | 'CO_DECISION' | 'CO_EXECUTION';
+/**
+ * An aggregated score for one of the four bridging components, built from
+ * individual corridor-opening events where life-side and cyber-side activity
+ * referenced the same worldmodel element (invariant / signal / lens / context).
+ */
+interface BridgingComponentScore extends ScoredObservation {
+    component: BridgingComponent;
+}
+/**
+ * Sentinel states a score can take when no number is meaningful.
+ *
+ *   INSUFFICIENT_EVIDENCE — the dimension/entity exists in this universe, but
+ *     not enough observed evidence passed the presence gate.
+ *   UNAVAILABLE — the measurement is structurally undefined. Currently only
+ *     used for N when no worldmodel is loaded (no shared universe for the
+ *     gyroscopes to register against).
+ */
+type ScoreSentinel = 'INSUFFICIENT_EVIDENCE' | 'UNAVAILABLE';
+/**
+ * An entity or composite score: a number in [0, 100] when computable, or a
+ * sentinel explaining why no number is available.
+ */
+type Score = number | ScoreSentinel;
+/** Type guard: this Score is a usable number. */
+declare function isScored(s: Score): s is number;
+/** Type guard: this Score is a sentinel. */
+declare function isSentinel(s: Score): s is ScoreSentinel;
+/**
+ * Radiant's read on whether observed activity aligns with the stated
+ * worldmodel. Orthogonal to engine-level ViabilityStatus (which describes
+ * whether the worldmodel itself remains structurally coherent). Both surface
+ * side-by-side; neither is collapsed into the other.
+ *
+ * INSUFFICIENT_EVIDENCE is first-class. Silence is never scored as neutral.
+ */
+type AlignmentStatus = 'STRONG' | 'STABLE' | 'WATCHING' | 'FRAGILE' | 'MISALIGNED' | 'INSUFFICIENT_EVIDENCE';
+/**
+ * An observed behavioral pattern identified by AI pattern interpretation.
+ * Two kinds:
+ *
+ *   canonical — the worldmodel declared this pattern by name (e.g.
+ *     'coordination_drift' as an evolution-layer pattern). The AI
+ *     identified it in the activity.
+ *   candidate — the AI noticed a pattern the worldmodel hasn't
+ *     declared. Surfaces as "emergent," and accumulates across runs as
+ *     a potential worldmodel-evolution proposal.
+ *
+ * Step 5 produces these via AI interpretation + guard-engine governance
+ * (evidence gate, invariant check, no-hallucination check). Step 6 (the
+ * rendering lens) transforms them by annotating framing + emphasis
+ * metadata before the renderer turns them into output text.
+ */
+interface ObservedPattern {
+    name: string;
+    type: 'canonical' | 'candidate';
+    /** If canonical, the worldmodel-declared pattern name this matched. */
+    declaredAs?: string;
+    /** Description of the pattern, in lens voice. */
+    description: string;
+    /** Evidence the AI cited when naming this pattern. */
+    evidence: PatternEvidence;
+    /** Rendering-lens annotation: which framing applies. Set by lens.rewrite. */
+    framing?: string;
+    /** Rendering-lens annotation: what this lens wants weighted. Set by lens.rewrite. */
+    emphasis?: string;
+    /** Rendering-lens annotation: should the renderer compress? Set by lens.rewrite. */
+    compress?: boolean;
+    /** AI's confidence in the observation, 0–1. */
+    confidence: number;
+}
+interface PatternEvidence {
+    /** Signal cell refs, e.g. 'alignment.life', 'follow_through.joint'. */
+    signals: string[];
+    /** Event IDs grounding the pattern. */
+    events: string[];
+    /** If the pattern cites a worldmodel invariant (especially for candidates). */
+    cited_invariant?: string;
+}
+/**
+ * A rendering lens: a deterministic transform applied to patterns + a set
+ * of voice / vocabulary / framing rules enforced at the renderer.
+ *
+ * Three parts:
+ *   1. primary_frame — the analytical framework the AI is prompted to
+ *      reason through when interpreting activity (e.g. the vanguard
+ *      three-domain scoring).
+ *   2. vocabulary + voice — terms to prefer, terms to avoid, forbidden
+ *      phrasings, preferred phrasings, register directives.
+ *   3. rewrite + exemplar refs — the pattern-transform function and
+ *      pointers to ground-truth reference material for calibration.
+ *
+ * Guardrails (enforced by the guard engine + the renderer):
+ *   - cannot invent new signals
+ *   - cannot override evidence
+ *   - cannot hallucinate intent
+ *   - cannot change what is true; only what is emphasized or framed
+ */
+interface RenderingLens {
+    name: string;
+    description: string;
+    /** The primary analytical framework — what the AI reasons through first. */
+    primary_frame: PrimaryFrame;
+    /** Vocabulary map — generic → lens-native term substitutions. */
+    vocabulary: LensVocabulary;
+    /** Register, tone, specificity, and other voice-level directives. */
+    voice: VoiceDirectives;
+    /** Phrasings that fail the renderer if present in output. */
+    forbidden_phrases: readonly string[];
+    /** Phrasings/patterns the lens prefers — calibration for the renderer. */
+    preferred_patterns: readonly string[];
+    /**
+     * Strategic decision patterns the lens encodes. When the AI proposes a
+     * move, these patterns inform how it frames the recommendation.
+     */
+    strategic_patterns: readonly string[];
+    /**
+     * Pointers to exemplar reference material — worked examples of this
+     * lens's primary_frame being implemented in practice. Used for:
+     *   - few-shot grounding in the AI prompt
+     *   - voice calibration against ground-truth output
+     *   - evaluation baselines for testing the lens's effect
+     */
+    exemplar_refs: readonly ExemplarRef[];
+    /**
+     * Pattern-transform function. Takes an ObservedPattern and annotates
+     * it with framing / emphasis / compress metadata. Pure function; no
+     * side effects; must not change `evidence` or `name`.
+     */
+    rewrite: (pattern: ObservedPattern) => ObservedPattern;
+}
+/**
+ * The primary analytical framework declared by a lens. For the vanguard
+ * lens this is the three-domain scoring (Future Foresight, Narrative
+ * Dynamics, Shared Prosperity) with its overlap emergent states.
+ *
+ * The AI is prompted to reason through this framework first when
+ * interpreting activity. It answers the evaluation questions and names
+ * which domains are present, which are weak, and which overlaps light up.
+ */
+interface PrimaryFrame {
+    /** Domain identifiers (kebab-case), e.g. ['future-foresight', 'narrative-dynamics', 'shared-prosperity']. */
+    domains: readonly string[];
+    /** Named emergent states produced when specific pairs of domains overlap. */
+    overlaps: readonly OverlapDef[];
+    /** The center identity — what the system becomes when all domains integrate. */
+    center_identity: string;
+    /** Questions the AI is prompted to answer when applying this frame. */
+    evaluation_questions: readonly string[];
+    /** Description of how to apply the frame to activity. */
+    scoring_rubric: string;
+}
+interface OverlapDef {
+    /** The two domain identifiers this overlap joins. Order-insensitive. */
+    domains: readonly [string, string];
+    /** The emergent state the overlap produces (e.g. 'Inspiration'). */
+    emergent_state: string;
+    /** Short description of what this overlap looks like in practice. */
+    description: string;
+}
+interface LensVocabulary {
+    /** Proper nouns the lens expects to appear verbatim (not paraphrased). */
+    proper_nouns: readonly string[];
+    /**
+     * Generic term → lens-native replacement. The renderer substitutes
+     * generic phrasings with lens-native ones. E.g. `'device': 'participant'`.
+     */
+    preferred: Record<string, string>;
+    /** Architectural vocabulary specific to this lens's domain. */
+    architecture: readonly string[];
+    /** Economic / resource vocabulary specific to this lens's domain. */
+    economic: readonly string[];
+    /** Framing and mission-level vocabulary for this lens. */
+    framing: readonly string[];
+    /**
+     * System-internal concepts → plain English. Applied to OUTPUT only —
+     * before the AI surfaces a description, it must translate any of these
+     * terms into their right-column equivalent. Readers don't know Radiant's
+     * internal vocabulary; speaking it to them creates false precision.
+     *
+     * E.g. 'worldmodel' → 'your strategy file', 'candidate pattern' →
+     * 'something noticed but not yet tracked by name'.
+     */
+    jargon_translations: Record<string, string>;
+}
+interface VoiceDirectives {
+    /** Register in which the lens speaks (e.g. 'diagnosis mode'). */
+    register: string;
+    /** Active-voice requirement. */
+    active_voice: 'required' | 'preferred' | 'flexible';
+    /** Specificity requirement — names, numbers, places. */
+    specificity: 'required' | 'preferred' | 'flexible';
+    /** How the lens treats hype vocabulary. */
+    hype_vocabulary: 'forbidden' | 'discouraged' | 'allowed';
+    /** How the lens treats hedged / qualified phrasing. */
+    hedging: 'forbidden' | 'discouraged' | 'allowed';
+    /** Whether playfulness is allowed in this register. */
+    playfulness: 'allowed' | 'rare' | 'forbidden';
+    /** Whether output should close with a strategic-frame sentence. */
+    close_with_strategic_frame: 'preferred' | 'required' | 'optional';
+    /** Whether the "punchline move" (rhythm-break emphasis) is sanctioned. */
+    punchline_move: 'sparing' | 'frequent' | 'avoided';
+    /** Whether the lens requires honesty about what isn't working. */
+    honesty_about_failure: 'required' | 'preferred' | 'optional';
+    /**
+     * Reason-internally / express-externally directive.
+     *
+     * Some lens frames (like the vanguard three-domain scoring) are
+     * model-maker scaffolds — useful for AI reasoning, confusing as
+     * reader-facing labels. This directive tells the AI to reason
+     * through bucket-level concepts but express findings in the
+     * skill-level vocabulary inside each bucket. Bucket names live in
+     * `forbidden_phrases` so the renderer enforces the rule at build
+     * time; this directive gives the AI the "why" to cooperate
+     * upstream of the enforcement.
+     */
+    output_translation: string;
+}
+/**
+ * Pointer to a reference exemplar — a worked example of this lens's
+ * primary_frame being implemented. These live under
+ * `src/radiant/examples/<org>/exemplars/`.
+ */
+interface ExemplarRef {
+    /** Path relative to the exemplars directory. */
+    path: string;
+    /** Short title for this exemplar. */
+    title: string;
+    /** Which domains from the primary_frame this exemplar exhibits. */
+    exhibits: readonly string[];
+    /**
+     * Integration quality: 'full' (all domains present + integrated),
+     * 'partial' (some domains strong, others absent), 'primary-dominant'
+     * (one domain dominates), etc. Free-form.
+     */
+    integration_quality: string;
+    /** Notes about what this exemplar teaches for lens calibration. */
+    notes: string;
+}
+
+/**
+ * @neuroverseos/governance/radiant — L / C / N / R scoring math
+ *
+ * Presence-based averaging over asymmetric Life and Cyber capability spaces.
+ * No weights. No coefficients. Silence is never scored as neutral.
+ *
+ * Implements the Universal Math section of radiant/PROJECT-PLAN.md.
+ * The canonical formulas live there; this file is their runtime.
+ */
+
+/**
+ * A dimension or bridging component is present iff
+ *   event_count >= k  AND  confidence >= c.
+ *
+ * Absent items are excluded from averages — never zero-scored.
+ */
+declare function isPresent(o: Pick<ScoredObservation, 'eventCount' | 'confidence'>, gate?: EvidenceGate): boolean;
+/**
+ * Average the scores of items that pass the presence gate. Returns
+ * INSUFFICIENT_EVIDENCE if none pass.
+ *
+ * This is the single averaging primitive — all entity scores (L, C, N) and
+ * the composite R are built from it.
+ */
+declare function presenceAverage(items: ReadonlyArray<ScoredObservation>, gate?: EvidenceGate): Score;
+/**
+ * Life gyroscope score. Averages over present life-native dimensions.
+ *
+ *   Pure cognition team (only COG present) → L = score(COG) — full 0–100.
+ *   All three active → L = avg(COG, CRE, SEN).
+ *   No dimension present → L = INSUFFICIENT_EVIDENCE.
+ */
+declare function scoreLife(capability: LifeCapability, gate?: EvidenceGate): Score;
+/**
+ * Cyber gyroscope score. Averages over present cyber-native dimensions.
+ *
+ * Same shape as scoreLife, but operates on a distinct (asymmetric) dimension
+ * set. A human exercising COG while an AI exercises AR are both fully
+ * engaged — neither is "off," and this math does not force symmetry.
+ */
+declare function scoreCyber(capability: CyberCapability, gate?: EvidenceGate): Score;
+/**
+ * NeuroVerse coherence. Translation quality through open corridors.
+ *
+ *   No worldmodel loaded → UNAVAILABLE. There is no shared universe for the
+ *     gyroscopes to register against; coherence is undefined, not zero.
+ *   Worldmodel loaded, no corridor-opening evidence passes the gate →
+ *     INSUFFICIENT_EVIDENCE.
+ *   Otherwise → presence-average over the four bridging components.
+ *
+ * High L and high C can still produce low N: two excellent intelligences
+ * working past each other without opening a corridor score low. That is
+ * the correct behavior — N is not synchronization.
+ */
+declare function scoreNeuroVerse(components: ReadonlyArray<BridgingComponentScore>, worldmodelLoaded: boolean, gate?: EvidenceGate): Score;
+/**
+ * Composite alignment. Averages over whichever entity alignments are
+ * available, excluding any in INSUFFICIENT_EVIDENCE or UNAVAILABLE.
+ *
+ *   All-human deployment (A_C unavailable) → R = A_L.
+ *   All-AI pipeline (A_L unavailable) → R = A_C.
+ *   Hybrid with worldmodel loaded → R = avg(A_L, A_C, A_N).
+ *   Nothing available → R = INSUFFICIENT_EVIDENCE.
+ *
+ * Sentinels are excluded, not zeroed. A missing entity does not drag R down.
+ */
+declare function scoreComposite(a_L: Score, a_C: Score, a_N: Score): Score;
+
+/**
+ * @neuroverseos/governance/radiant — actor_domain classification
+ *
+ * Every event in Radiant's pipeline is tagged `life`, `cyber`, or `joint`
+ * before signals are extracted. This is the fixed, universal classifier —
+ * declared as part of the NeuroverseOS universe, not a per-worldmodel choice.
+ *
+ *   life   — human actions alone (commits authored by people, human reviews,
+ *             human-written decisions)
+ *   cyber  — AI or bot actions alone (AI-generated code, automated comments,
+ *             bot commits)
+ *   joint  — activity where human and AI both participated: a human accepting
+ *             or rejecting AI output, iterative co-edits, co-authored commits,
+ *             escalation loops between life-side and cyber-side
+ *
+ * The classifier is deterministic and pure. It looks only at the event's
+ * actor metadata and its relationships (co-actors, respondsTo). Adapters
+ * are responsible for populating those fields accurately from their source
+ * of truth (GitHub, ExoCortex, chat, etc.).
+ *
+ * See radiant/PROJECT-PLAN.md — "actor_domain Classification".
+ */
+/**
+ * What kind of actor produced an event.
+ *
+ *   human   — a person
+ *   ai      — an AI agent (Claude, Copilot-generated code, agent output)
+ *   bot     — a non-AI automated actor (dependabot, CI bots, webhook bots)
+ *   unknown — actor kind cannot be determined from available evidence
+ *
+ * `bot` is grouped with `ai` on the cyber side of the boundary — from the
+ * gyroscope's perspective, both are non-human actors operating in the
+ * universe. The distinction may matter to specific signals but not to the
+ * domain classifier.
+ */
+type ActorKind = 'human' | 'ai' | 'bot' | 'unknown';
+/** An entity that produced or participated in an event. */
+interface Actor {
+    id: string;
+    kind: ActorKind;
+    name?: string;
+}
+/** A reference to a prior event this one responds to. */
+interface EventReference {
+    eventId: string;
+    actor: Actor;
+}
+/**
+ * A minimal event shape sufficient for domain classification and downstream
+ * signal extraction. Adapters (GitHub, ExoCortex, chat) populate these
+ * fields from their respective source of truth.
+ *
+ * The classifier in this file only reads `actor`, `coActors`, and
+ * `respondsTo`. Signal extractors (step 4) additionally read `kind` and
+ * `content`. Later steps may extend this interface; keep additions
+ * optional so existing adapters remain compatible.
+ */
+interface Event {
+    id: string;
+    timestamp: string;
+    actor: Actor;
+    /** Additional participants (e.g. Co-authored-by trailers on a commit). */
+    coActors?: Actor[];
+    /** If this event is a reply, review, merge, or edit of a prior event. */
+    respondsTo?: EventReference;
+    /**
+     * Loose event-kind tag from the adapter — e.g. `commit`, `pr_opened`,
+     * `pr_review`, `issue_comment`, `chat_message`. Free-form string so any
+     * adapter can declare its own kinds; signal extractors interpret them.
+     */
+    kind?: string;
+    /**
+     * Human-meaningful textual content of the event — commit message, PR
+     * description, review body, chat message body, etc. Used by signal
+     * extractors to score clarity and related signals.
+     */
+    content?: string;
+    /** Adapter-specific structured data, opaque to core Radiant. */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * The three-way domain tag applied to every event. Drives which gyroscope's
+ * capability space the event contributes to (life or cyber), or — for joint
+ * events — feeds the bridging-component scoring that powers N.
+ */
+type ActorDomain = 'life' | 'cyber' | 'joint';
+/**
+ * Tag an event as `life`, `cyber`, or `joint`.
+ *
+ * Rules, in order:
+ *
+ *   1. Mixed authorship → joint. If the event has co-actors and the
+ *      combined set spans both life-side and cyber-side, the event is
+ *      joint regardless of who's primary. A commit with a human author
+ *      and an AI co-author is joint.
+ *
+ *   2. Cross-boundary response → joint. If the event is a response to a
+ *      prior event whose actor is on the opposite side of the boundary,
+ *      the event is joint. A human merging an AI-authored PR is joint.
+ *      An AI commenting on a human-authored issue is joint.
+ *
+ *   3. Otherwise, classify by the primary actor's kind.
+ *      - ai | bot  → cyber
+ *      - human | unknown → life
+ *
+ * Rule 3's `unknown → life` default is deliberate: most events in most
+ * systems come from humans. When an adapter cannot determine actor kind,
+ * the event is assumed human until proven otherwise. Upgrading requires
+ * positive evidence (a bot user-agent, an AI signature, a "Co-authored-by:
+ * Claude" trailer, etc.), never absence.
+ */
+declare function classifyActorDomain(event: Event): ActorDomain;
+
+/**
+ * @neuroverseos/governance/radiant — Auki Builder Lens
+ *
+ * A rendering lens that prompts the AI to reason through Auki's vanguard
+ * leadership model when interpreting activity, and enforces voice /
+ * vocabulary / framing rules consistent with how Auki builders
+ * communicate when that model is in effect.
+ *
+ * The lens does NOT capture any specific person's speaking patterns.
+ * It captures the vanguard leadership operating system — codified as the
+ * three-domain analytical frame (Future Foresight, Narrative Dynamics,
+ * Shared Prosperity) together with the voice and vocabulary an Auki
+ * builder uses when that operating system is running.
+ *
+ * The vanguard worldmodel (src/worlds/auki-vanguard.worldmodel.md) is the
+ * abstract DNA. This lens is how that DNA speaks and thinks.
+ *
+ * Exemplars — worked instances of the vanguard model being implemented —
+ * live at src/radiant/examples/auki/exemplars/. The lens references them
+ * for calibration: when applying this lens, the AI's output should fall
+ * in the same neighborhood as those exemplars, not match them verbatim.
+ *
+ * Guardrails (enforced downstream):
+ *   - cannot invent new signals
+ *   - cannot override evidence
+ *   - cannot hallucinate intent
+ *   - cannot change what is true; only what is emphasized and framed
+ *
+ * See radiant/PROJECT-PLAN.md §"Three-Layer Interpretation Architecture".
+ */
+
+/**
+ * The Auki Builder Lens. A first-class npm export under
+ * `@neuroverseos/governance/radiant/lenses`, consumable by the
+ * `neuroverse radiant think` / `emergent` / `decision` commands.
+ *
+ * The lens is Auki-specific *content* in the form of a generic
+ * RenderingLens primitive. The extraction to generic OSS Radiant
+ * replaces this file's content with a template scaffold; the surrounding
+ * code (renderer, MCP server, lens system) stays unchanged.
+ */
+declare const aukiBuilderLens: RenderingLens;
+
+/**
+ * @neuroverseos/governance/radiant/lenses
+ *
+ * Rendering lenses — the third of the three interpretation layers
+ * described in radiant/PROJECT-PLAN.md. Each lens is a deterministic
+ * pattern-transform plus a set of voice / vocabulary / framing rules.
+ *
+ * Lenses are first-class npm exports. Registering a new lens means
+ * exporting its definition from this file. The `neuroverse radiant`
+ * commands accept a `--lens <id>` flag and resolve it against the
+ * registered set.
+ *
+ * Current registry:
+ *   - auki-builder — Auki's vanguard leadership lens. Reason internally
+ *     through Future Foresight / Narrative Dynamics / Shared Prosperity;
+ *     express externally with the skill-level vocabulary inside each
+ *     domain. See ./auki-builder.ts for the content.
+ *
+ * To add a new lens:
+ *   1. Create src/radiant/lenses/<name>.ts exporting a `RenderingLens`.
+ *   2. Re-export it from this file.
+ *   3. Add it to `LENSES` below.
+ *   4. If it's an Auki-specific lens, live alongside auki-builder here.
+ *     If it's a generic OSS lens, start a fresh family.
+ */
+
+/**
+ * Registered lenses keyed by name. Consumers (CLI, MCP server, tests)
+ * resolve a lens by id through this map.
+ */
+declare const LENSES: Readonly<Record<string, RenderingLens>>;
+/**
+ * Resolve a lens by id. Returns undefined if not registered — callers
+ * should surface a clear error rather than silently falling back to a
+ * default lens (which would violate the voice/framing enforcement).
+ */
+declare function getLens(id: string): RenderingLens | undefined;
+/**
+ * List all registered lens ids. Used by `neuroverse radiant lenses list`.
+ */
+declare function listLenses(): readonly string[];
+
+/**
+ * @neuroverseos/governance/radiant — signal extraction
+ *
+ * Step 4: turn a list of classified events into the 5 × 3 signal matrix
+ * that downstream steps (pattern composition, rendering lens, renderer)
+ * read to produce alignment output.
+ *
+ * The matrix is:  { signal_id × actor_domain } → ScoredObservation,
+ * i.e. 5 signals × 3 domains (life / cyber / joint) = 15 cells by default.
+ * Scores are 0–100 and each cell reports its own eventCount and confidence
+ * so the evidence gate (from step 2) can decide presence downstream.
+ *
+ * Defaults declared by the NeuroVerse base worldmodel:
+ *   clarity · ownership · follow_through · alignment · decision_momentum
+ *
+ * A worldmodel can declare additional signals by providing extra extractors.
+ * The extractor interface is deterministic and stateless — no LLM calls, no
+ * heuristics that depend on run order.
+ *
+ * Step-4 scope note: the default extractors below are intentionally simple
+ * heuristics. They produce defensible numbers on synthetic and real events,
+ * but Phase-4 validation with Auki's repos is where the scoring gets tuned.
+ * Extractors are pluggable precisely so they can be replaced without
+ * touching downstream math.
+ */
+
+/**
+ * An Event that has been tagged with its ActorDomain. Produced by
+ * `classifyEvents` and consumed by extractors. Pre-classifying once avoids
+ * re-running the classifier for every (signal × domain) cell.
+ */
+interface ClassifiedEvent {
+    event: Event;
+    domain: ActorDomain;
+}
+/**
+ * One cell of the signal matrix: a score for a given signal in a given
+ * actor_domain. Downstream math reads `score`, `eventCount`, `confidence`
+ * and passes each cell through the evidence gate.
+ */
+interface Signal {
+    id: string;
+    domain: ActorDomain;
+    score: number;
+    eventCount: number;
+    confidence: number;
+}
+/** The computed 5 × 3 matrix (or whichever dimensions the extractors define). */
+type SignalMatrix = readonly Signal[];
+/**
+ * The three-tuple a SignalExtractor returns for a given (signal, domain).
+ */
+interface ExtractionResult {
+    score: number;
+    eventCount: number;
+    confidence: number;
+}
+/**
+ * A named extraction routine. Given all classified events and a target
+ * domain, produce a score for this signal in that domain.
+ *
+ * Extractors must be:
+ *   - deterministic (same input → same output)
+ *   - stateless (no hidden mutable state between calls)
+ *   - side-effect free (no IO, no LLM calls, no wall-clock reads)
+ *
+ * An extractor that can't score its signal in a given domain should still
+ * return a well-formed ExtractionResult — typically `{ score: 0,
+ * eventCount: 0, confidence: 0 }` — which the evidence gate will filter
+ * out as not-present.
+ */
+interface SignalExtractor {
+    id: string;
+    description: string;
+    extract(events: readonly ClassifiedEvent[], domain: ActorDomain): ExtractionResult;
+}
+/**
+ * Tag every event with its domain, once. Downstream extractors read the
+ * tagged stream without reclassifying.
+ */
+declare function classifyEvents(events: readonly Event[]): ClassifiedEvent[];
+/**
+ * Compute the signal matrix. For each extractor × each domain, run the
+ * extractor and collect the resulting Signal.
+ *
+ * The output is a flat list of Signal cells. Consumers that need the matrix
+ * by name or by domain can group as needed; keeping the wire format flat
+ * avoids encoding the domain enumeration in the shape.
+ */
+declare function extractSignals(events: readonly ClassifiedEvent[], extractors?: readonly SignalExtractor[]): SignalMatrix;
+/**
+ * The five default extractors declared by the NeuroVerse base worldmodel.
+ * Each is a simple, defensible heuristic for Phase 1 — all are pluggable
+ * and intended to be tuned against real deployment data in Phase 4.
+ */
+declare const DEFAULT_SIGNAL_EXTRACTORS: readonly SignalExtractor[];
+
+/**
+ * @neuroverseos/governance/radiant — system prompt composer
+ *
+ * Reads worldmodel content (markdown) + a RenderingLens and composes the
+ * system prompt that governs the AI's reasoning and output.
+ *
+ * Pure function. No AI calls. No IO. Deterministic: same inputs, same
+ * string output. Testable without an API key.
+ *
+ * The composed prompt has four sections:
+ *   1. Worldmodel context — the compiled worldmodel(s) as readable markdown
+ *   2. Analytical frame — the lens's primary_frame (how to reason)
+ *   3. Voice + vocabulary — the lens's voice directives + vocabulary map
+ *   4. Guardrails — forbidden phrases + output translation discipline
+ *
+ * The AI receives this as a system message. The user's query is a separate
+ * user message. The separation means the system prompt can be cached across
+ * queries (if the worldmodel + lens haven't changed).
+ */
+
+/**
+ * Compose the system prompt from worldmodel content + rendering lens.
+ *
+ * @param worldmodelContent — raw markdown of the worldmodel source file(s).
+ *   If multiple worldmodels are loaded, concatenate them with a separator.
+ * @param lens — the active rendering lens.
+ * @returns a system prompt string ready for the AI's system message.
+ */
+declare function composeSystemPrompt(worldmodelContent: string, lens: RenderingLens): string;
+
+/**
+ * @neuroverseos/governance/radiant — voice check
+ *
+ * Post-processes AI output to detect forbidden phrases from the active
+ * rendering lens. Returns violations. The caller (CLI, MCP server,
+ * renderer) decides what to do — fail, warn, or retry.
+ *
+ * Pure function. No AI calls. Deterministic.
+ */
+
+/**
+ * A detected forbidden-phrase violation in the output text.
+ */
+interface VoiceViolation {
+    /** The forbidden phrase that was matched (case-insensitive). */
+    phrase: string;
+    /** Character offset where the phrase was found. */
+    offset: number;
+}
+/**
+ * Check text for forbidden phrases from the active lens.
+ *
+ * Match is case-insensitive substring. Returns all violations found,
+ * in order of appearance. Empty array = clean output.
+ */
+declare function checkForbiddenPhrases(lens: RenderingLens, text: string): VoiceViolation[];
+
+/**
+ * @neuroverseos/governance/radiant — AI adapter
+ *
+ * Abstract interface for calling an LLM, plus a concrete Anthropic
+ * implementation using raw fetch (no SDK dependency).
+ *
+ * The interface is intentionally thin — one function, string in, string
+ * out. The system prompt is composed upstream by `composeSystemPrompt`;
+ * the AI adapter just sends it and the user query, returns the response.
+ *
+ * Phase 1 targets Anthropic Claude. The interface is generic enough to
+ * add OpenAI, LangChain, or local-model implementations later.
+ */
+/**
+ * A minimal AI completion interface. Implementors call an LLM with a
+ * system prompt and a user query and return the response text.
+ */
+interface RadiantAI {
+    complete(systemPrompt: string, userQuery: string): Promise<string>;
+}
+/**
+ * Create an Anthropic Claude AI adapter using raw fetch (no SDK).
+ *
+ * @param apiKey — Anthropic API key. Read from ANTHROPIC_API_KEY env.
+ * @param model — model identifier. Default: claude-sonnet-4-20250514.
+ * @param maxTokens — max tokens for the response. Default: 4096.
+ */
+declare function createAnthropicAI(apiKey: string, model?: string, maxTokens?: number): RadiantAI;
+/**
+ * Create a mock AI adapter for testing. Returns a fixed response
+ * without calling any API.
+ */
+declare function createMockAI(fixedResponse: string): RadiantAI;
+
+/**
+ * @neuroverseos/governance/radiant — scope resolution
+ *
+ * Parses scope strings like "aukiverse/posemesh" into typed scope objects
+ * that adapters (GitHub, etc.) know how to fetch.
+ */
+/**
+ * A GitHub repository scope — the unit of activity Radiant reads.
+ */
+interface RepoScope {
+    owner: string;
+    repo: string;
+}
+/**
+ * Parse a scope string into a RepoScope.
+ *
+ * Accepts:
+ *   "owner/repo"
+ *   "https://github.com/owner/repo"
+ *   "github.com/owner/repo"
+ *
+ * Throws on unparseable input.
+ */
+declare function parseRepoScope(scope: string): RepoScope;
+/**
+ * Format a RepoScope back to a display string.
+ */
+declare function formatScope(scope: RepoScope): string;
+
+/**
+ * @neuroverseos/governance/radiant — GitHub activity adapter
+ *
+ * Fetches recent activity from a GitHub repository and maps it to
+ * Radiant's Event type. This is the data source for the behavioral
+ * analysis pipeline (signals → patterns → alignment scores).
+ *
+ * Uses raw fetch (no Octokit dependency). Requires a GitHub token
+ * with repo read access (fine-grained PAT or classic with `repo` scope).
+ *
+ * What it fetches:
+ *   - Recent commits (with author, message, co-authors)
+ *   - Recent pull requests (with description, author, state)
+ *   - Recent PR reviews (with reviewer, state, body)
+ *   - Recent issue/PR comments (with author, body, reference)
+ *
+ * Actor classification:
+ *   - GitHub user type "Bot" → ActorKind 'bot'
+ *   - Login ending in "[bot]" → ActorKind 'bot'
+ *   - Co-authored-by trailers naming known AI tools → ActorKind 'ai'
+ *   - Everything else → ActorKind 'human'
+ *
+ * Pagination: fetches one page per endpoint (up to perPage items).
+ * Sufficient for most repos' 14-day windows. Full pagination is a
+ * future refinement.
+ */
+
+interface GitHubFetchOptions {
+    /** How many days of history to fetch. Default: 14. */
+    windowDays?: number;
+    /** Items per page per endpoint. Default: 100. */
+    perPage?: number;
+}
+/**
+ * Fetch recent activity from a GitHub repo and return Radiant Events.
+ *
+ * @param scope — owner/repo
+ * @param token — GitHub personal access token
+ * @param options — window size and pagination
+ */
+declare function fetchGitHubActivity(scope: RepoScope, token: string, options?: GitHubFetchOptions): Promise<Event[]>;
+/**
+ * Create a mock GitHub adapter for testing. Returns fixed events
+ * without calling the GitHub API.
+ */
+declare function createMockGitHubAdapter(fixedEvents: Event[]): typeof fetchGitHubActivity;
+
+/**
+ * @neuroverseos/governance/radiant — ExoCortex adapter
+ *
+ * Reads stated intent from an exocortex directory. This is the "should"
+ * side of the intent-vs-behavior comparison. GitHub provides the "did."
+ * Radiant reads both and surfaces where they diverge.
+ *
+ * The adapter reads standard exocortex files:
+ *   - attention.md — what the person/team is focused on RIGHT NOW
+ *   - goals.md — what they're working toward
+ *   - identity.md — who they are, what they value
+ *   - sprint.md or src/sprint.md — current sprint focus
+ *   - org/organization.md — org mission and values (if symlinked)
+ *   - org/methods.md — how the org operates (if symlinked)
+ *
+ * Returns a structured ExocortexContext that the AI interpretation
+ * prompt uses to compare stated intent against observed behavior.
+ *
+ * All file reads are optional — missing files are silently skipped.
+ * An exocortex with only attention.md is still useful.
+ */
+interface ExocortexContext {
+    /** What the person/team says they're focused on right now. */
+    attention: string | null;
+    /** What they're working toward. */
+    goals: string | null;
+    /** Who they are, what they value. */
+    identity: string | null;
+    /** Current sprint focus. */
+    sprint: string | null;
+    /** Org mission and values (from org/organization.md). */
+    organization: string | null;
+    /** How the org operates (from org/methods.md). */
+    methods: string | null;
+    /** The directory path that was read. */
+    source: string;
+    /** How many files were found and loaded. */
+    filesLoaded: number;
+}
+/**
+ * Read stated intent from an exocortex directory.
+ *
+ * Silently skips missing files. Returns whatever it finds. An exocortex
+ * with only attention.md is still useful — partial context is better
+ * than no context.
+ */
+declare function readExocortex(dirPath: string): ExocortexContext;
+/**
+ * Format the exocortex context as a section for the AI interpretation
+ * prompt. Only includes fields that were actually loaded.
+ */
+declare function formatExocortexForPrompt(ctx: ExocortexContext): string;
+/**
+ * One-line summary of what was loaded, for CLI status output.
+ */
+declare function summarizeExocortex(ctx: ExocortexContext): string;
+
+/**
+ * @neuroverseos/governance/radiant — AI pattern interpretation
+ *
+ * Step 5 (reframed): the AI identifies patterns in the signal matrix
+ * and event stream, governed by the worldmodel's invariants and the
+ * rendering lens's voice constraints.
+ *
+ * Hybrid vocabulary:
+ *   - canonical: patterns the worldmodel declares (the AI labels them
+ *     when it sees matching evidence)
+ *   - candidate: patterns the AI discovers that the worldmodel hasn't
+ *     declared (surfaced as "emergent," tracked for worldmodel evolution)
+ *
+ * Guardrails (enforced by interpretPatterns):
+ *   - Every pattern must cite specific signals and events (no hallucination)
+ *   - Candidate patterns are explicitly labeled as not-yet-in-worldmodel
+ *   - The AI prompt includes the lens's forbidden phrases + voice rules
+ *   - Output is parsed + validated before being returned
+ *
+ * The AI does the thinking. The governance layer checks the work.
+ */
+
+interface InterpretInput {
+    /** The 5×3 signal matrix from extractSignals. */
+    signals: readonly Signal[];
+    /** Classified events from the adapter. */
+    events: readonly ClassifiedEvent[];
+    /** Raw worldmodel content (markdown). */
+    worldmodelContent: string;
+    /** The active rendering lens. */
+    lens: RenderingLens;
+    /** AI adapter to call for interpretation. */
+    ai: RadiantAI;
+    /** Known canonical pattern names from the worldmodel (optional). */
+    canonicalPatterns?: readonly string[];
+    /** Stated intent from the exocortex (optional). When present, the AI
+     *  compares stated intent against observed behavior and surfaces gaps. */
+    statedIntent?: string;
+}
+interface InterpretResult {
+    patterns: ObservedPattern[];
+    /** A strategic thesis paragraph (3-5 sentences) weaving patterns into one argument. */
+    meaning: string;
+    /** 1-3 direct imperatives, OR explicit acknowledgment that nothing needs action. */
+    move: string;
+    raw_ai_response: string;
+}
+/**
+ * Ask the AI to identify patterns in the signal matrix + event stream.
+ *
+ * The AI receives:
+ *   - The signal matrix summary
+ *   - A sample of recent events (capped for context length)
+ *   - The worldmodel context
+ *   - The lens's analytical frame (evaluation questions, voice rules)
+ *   - A list of canonical pattern names (if any)
+ *   - Instructions to produce structured JSON
+ *
+ * The response is parsed as JSON, validated, and each pattern is typed
+ * as canonical or candidate.
+ */
+declare function interpretPatterns(input: InterpretInput): Promise<InterpretResult>;
+
+/**
+ * @neuroverseos/governance/radiant — governance audit
+ *
+ * Runs each GitHub event through the NeuroverseOS guard engine against
+ * the compiled worldmodel. Produces an audit trail showing which events
+ * triggered governance (BLOCK/MODIFY), which side (human/AI/joint),
+ * and what invariants were tested.
+ *
+ * This is where Radiant meets the NeuroverseOS governance engine.
+ * Same evaluateGuard() that runs at API-level, applied retroactively
+ * to activity that already happened. The audit trail is the proof that
+ * the cocoon's walls are holding — or shows where they're being tested.
+ */
+
+interface GovernanceVerdict {
+    eventId: string;
+    domain: ActorDomain;
+    status: 'ALLOW' | 'BLOCK' | 'MODIFY' | 'PAUSE' | 'PENALIZE' | 'REWARD';
+    reason?: string;
+    ruleId?: string;
+    warning?: string;
+}
+interface GovernanceAudit {
+    totalEvents: number;
+    human: {
+        allow: number;
+        modify: number;
+        block: number;
+        details: GovernanceVerdict[];
+    };
+    cyber: {
+        allow: number;
+        modify: number;
+        block: number;
+        details: GovernanceVerdict[];
+    };
+    joint: {
+        allow: number;
+        modify: number;
+        block: number;
+        details: GovernanceVerdict[];
+    };
+    /** Summary for rendering — most important findings. */
+    summary: string;
+}
+/**
+ * Run each classified event through the guard engine against the compiled
+ * worldmodel. Returns a structured audit with human/cyber/joint breakdown.
+ *
+ * @param events — classified events from the GitHub adapter
+ * @param worldPath — path to a compiled .nv-world.md or world directory
+ */
+declare function auditGovernance(events: readonly ClassifiedEvent[], worldPath: string): Promise<GovernanceAudit>;
+
+/**
+ * @neuroverseos/governance/radiant — renderer
+ *
+ * Takes signals + patterns + scores + lens metadata and produces the
+ * structured output Nils reads. Two output modes:
+ *   - text: the EMERGENT / MEANING / MOVE structure for terminal display
+ *   - yaml+text: Memory Palace coded read file (YAML frontmatter + prose)
+ *
+ * The renderer enforces the lens's voice rules: forbidden phrases are
+ * checked, bucket names are never leaked, vocabulary is Auki-native.
+ */
+
+interface RenderInput {
+    scope: RepoScope;
+    windowDays: number;
+    eventCount: number;
+    signals: readonly Signal[];
+    patterns: readonly ObservedPattern[];
+    scores: {
+        A_L: Score;
+        A_C: Score;
+        A_N: Score;
+        R: Score;
+    };
+    lens: RenderingLens;
+    /** AI-generated meaning + move sections (from the interpretation step). */
+    meaning?: string;
+    move?: string;
+    /** Number of prior Radiant reads available (0 = first run). */
+    priorReadCount?: number;
+    /** Governance audit trail — events evaluated against the worldmodel. */
+    governance?: GovernanceAudit;
+}
+interface RenderOutput {
+    /** The human-readable text output for terminal display. */
+    text: string;
+    /** The Memory Palace coded YAML frontmatter (Tier 2 structured signals). */
+    frontmatter: string;
+}
+declare function render(input: RenderInput): RenderOutput;
+
+/**
+ * @neuroverseos/governance/radiant — Memory Palace file operations
+ *
+ * Writes Radiant reads to the exocortex as dated markdown files (with
+ * YAML frontmatter for structured signal data). Reads prior files to
+ * detect pattern persistence across runs.
+ *
+ * The exocortex directory IS the Memory Palace. Files are the tiers:
+ *   - reads/YYYY-MM-DD.md = Tier 2 (structured signals) + Tier 3 (narrative)
+ *   - knowledge.md = accumulated pattern facts with persistence counts
+ *
+ * No database. The file system is the time series. Git is the versioning.
+ */
+interface PriorRead {
+    date: string;
+    filename: string;
+    /** Pattern names found in this read (parsed from frontmatter). */
+    patternNames: string[];
+    /** Raw frontmatter content for signal comparison. */
+    frontmatter: string;
+}
+interface PatternPersistence {
+    name: string;
+    /** How many prior reads contained this pattern. */
+    occurrences: number;
+    /** Dates this pattern was observed. */
+    dates: string[];
+}
+/**
+ * Write a Radiant read to the exocortex. Creates the directory structure
+ * if it doesn't exist.
+ *
+ * @param exocortexDir — root of the exocortex (e.g. ~/exocortex/)
+ * @param frontmatter — YAML frontmatter (Tier 2 structured signals)
+ * @param text — prose output (Tier 3 narrative)
+ * @returns the path of the written file
+ */
+declare function writeRead(exocortexDir: string, frontmatter: string, text: string): string;
+/**
+ * Items from the worldmodel that Radiant tracks for subtraction proposals.
+ */
+interface WorldmodelItem {
+    type: 'invariant' | 'drift_behavior' | 'aligned_behavior' | 'decision_priority';
+    name: string;
+}
+/**
+ * Update the knowledge file with:
+ *   - Pattern persistence (what keeps recurring → consider adding)
+ *   - Subtraction proposals (what hasn't fired → consider removing)
+ *   - Active items (what recently triggered → keep)
+ *
+ * The leader reads this file and makes deliberate, rare, bidirectional
+ * changes to the worldmodel. Radiant proposes; the human decides.
+ */
+declare function updateKnowledge(exocortexDir: string, persistence: PatternPersistence[], options?: {
+    /** Items declared in the worldmodel (invariants, drift behaviors, etc.) */
+    declaredItems?: WorldmodelItem[];
+    /** Item names that triggered governance in this read */
+    triggeredItems?: string[];
+    /** Total number of reads completed (for "hasn't fired in N reads" tracking) */
+    totalReads?: number;
+}): string;
+/**
+ * Load prior Radiant reads from the exocortex. Returns them sorted by
+ * date (oldest first). Each read has its pattern names extracted from
+ * the frontmatter.
+ */
+declare function loadPriorReads(exocortexDir: string): PriorRead[];
+/**
+ * Compute pattern persistence across prior reads + the current patterns.
+ */
+declare function computePersistence(priorReads: PriorRead[], currentPatternNames: string[]): PatternPersistence[];
+/**
+ * Format prior-read context for the AI interpretation prompt.
+ * Tells the AI what patterns were seen in previous runs so it can
+ * reference persistence.
+ */
+declare function formatPriorReadsForPrompt(priorReads: PriorRead[]): string;
+
+/**
+ * @neuroverseos/governance/radiant — `think` command
+ *
+ * The first composable npm command: load worldmodels + a rendering lens,
+ * send a query to the AI with the composed system prompt, check the
+ * response for forbidden phrases, return the result.
+ *
+ * This is Stage A — the voice layer. No GitHub activity needed. No signal
+ * extraction. No pattern interpretation. Just: worldmodel + lens + AI + query.
+ *
+ * Usage (programmatic — CLI wiring lands in a follow-on commit):
+ *
+ *   import { think } from '@neuroverseos/governance/radiant';
+ *   const result = await think({
+ *     worldmodelContent: fs.readFileSync('./auki.worldmodel.md', 'utf-8'),
+ *     lensId: 'auki-builder',
+ *     query: 'Should we merge PR #247?',
+ *     ai: createAnthropicAI(process.env.ANTHROPIC_API_KEY!),
+ *   });
+ *   console.log(result.response);
+ */
+
+interface ThinkInput {
+    /** Raw markdown content of the worldmodel(s). Concatenate multiple with a separator. */
+    worldmodelContent: string;
+    /** Rendering lens id. Must be registered in LENSES. */
+    lensId: string;
+    /** The user's query — any natural-language question or prompt. */
+    query: string;
+    /** AI adapter instance (Anthropic, OpenAI, mock, etc.). */
+    ai: RadiantAI;
+}
+interface ThinkResult {
+    /** The AI's response text, after voice-check. */
+    response: string;
+    /** The lens that was applied. */
+    lens: string;
+    /** Any forbidden-phrase violations detected in the response. */
+    voiceViolations: VoiceViolation[];
+    /** Whether the response passed the voice check (no violations). */
+    voiceClean: boolean;
+    /** The system prompt that was composed (for transparency / debugging). */
+    systemPrompt: string;
+}
+/**
+ * Think through a query using the loaded worldmodel + rendering lens.
+ *
+ * The function:
+ *   1. Resolves the lens by id (fails if not registered)
+ *   2. Composes the system prompt from worldmodel content + lens
+ *   3. Calls the AI adapter with system prompt + user query
+ *   4. Checks the response for forbidden phrases
+ *   5. Returns the response + voice-check results
+ *
+ * The caller decides what to do with voice violations — surface them,
+ * retry, or accept the response as-is. The `think` command itself does
+ * not retry or modify the response.
+ */
+declare function think(input: ThinkInput): Promise<ThinkResult>;
+
+/**
+ * @neuroverseos/governance/radiant — `emergent` command
+ *
+ * The behavioral analysis command. Reads GitHub activity for a repo,
+ * classifies events, extracts signals, asks the AI to interpret patterns,
+ * computes L/C/N/R alignment scores, applies the rendering lens, and
+ * produces the EMERGENT / MEANING / MOVE output.
+ *
+ * This is the command that produces the output Nils reads.
+ *
+ * Usage (programmatic):
+ *   import { emergent } from '@neuroverseos/governance/radiant';
+ *   const result = await emergent({ scope, token, ... });
+ *   console.log(result.text);
+ *
+ * Usage (CLI — wired in cli/radiant.ts):
+ *   neuroverse radiant emergent aukiverse/posemesh --lens auki-builder
+ */
+
+interface EmergentInput {
+    scope: RepoScope;
+    githubToken: string;
+    worldmodelContent: string;
+    lensId: string;
+    ai: RadiantAI;
+    windowDays?: number;
+    canonicalPatterns?: readonly string[];
+    /** Path to an exocortex directory. When present, Radiant reads stated
+     *  intent (attention, goals, sprint) and compares against observed
+     *  behavior from GitHub. The gap is the most valuable signal. */
+    exocortexPath?: string;
+    /** Path to a compiled world directory (for governance audit).
+     *  When present, each event is evaluated through evaluateGuard
+     *  and the GOVERNANCE section appears in the output. */
+    worldPath?: string;
+}
+interface EmergentResult {
+    /** The rendered text output (EMERGENT / MEANING / MOVE). */
+    text: string;
+    /** The YAML frontmatter for Memory Palace coding. */
+    frontmatter: string;
+    /** Voice violations detected in AI output. */
+    voiceViolations: VoiceViolation[];
+    voiceClean: boolean;
+    /** Raw signal matrix for inspection. */
+    signals: readonly Signal[];
+    /** Raw scores for inspection. */
+    scores: {
+        A_L: Score;
+        A_C: Score;
+        A_N: Score;
+        R: Score;
+    };
+    /** Event count fetched from GitHub. */
+    eventCount: number;
+}
+declare function emergent(input: EmergentInput): Promise<EmergentResult>;
+
+/**
+ * @neuroverseos/governance/radiant
+ *
+ * Radiant — Behavioral Intelligence for Collaboration Systems.
+ *
+ * ExoCortex remembers what happened. Radiant understands what it means —
+ * relative to your culture and strategy — and tells you what to do next.
+ *
+ * This module consumes the existing worldmodel pipeline (parse → compile),
+ * guard engine, lens system, and signal schema exported from
+ * `@neuroverseos/governance`, and layers on top:
+ *
+ *   - L/C/N math (Life / Cyber gyroscopes inside the NeuroverseOS universe)
+ *   - actor_domain classification (life | cyber | joint)
+ *   - 5 signals × 3 domains = 15 behavioral values
+ *   - 5 named pattern compositions
+ *   - Rendering lens layer (auki-builder first) that transforms patterns
+ *     before the renderer sees them — deterministic shaping, no LLM in path
+ *   - Stateless commands: emergent, decision
+ *   - Stateful (via MemoryProvider) commands: drift, evolve
+ *   - Memory Palace 4-layer coding standard (compression / baselines /
+ *     knowledge / synthesis) with a SQLite reference implementation
+ *   - CLI entry (bin/radiant.ts) and MCP server entry (bin/radiant-mcp.ts)
+ *
+ * Build state: Phase 1 complete — voice layer, behavioral dashboard,
+ * MCP server, Memory Palace write-back, governance audit, ExoCortex
+ * handshake. See radiant/PROJECT-PLAN.md for the full roadmap.
+ *
+ * Usage:
+ *   import {
+ *     think, emergent, scoreLife, classifyActorDomain,
+ *     aukiBuilderLens, checkForbiddenPhrases,
+ *   } from '@neuroverseos/governance/radiant';
+ */
+declare const RADIANT_PACKAGE_VERSION = "0.0.0";
+
+export { type Actor, type ActorDomain, type ActorKind, type AlignmentStatus, type BridgingComponent, type BridgingComponentScore, type ClassifiedEvent, type CyberCapability, type CyberDimension, DEFAULT_EVIDENCE_GATE, DEFAULT_SIGNAL_EXTRACTORS, type EmergentInput, type EmergentResult, type Event, type EventReference, type EvidenceGate, type ExemplarRef, type ExocortexContext, type ExtractionResult, type GitHubFetchOptions, type GovernanceAudit, type GovernanceVerdict, type InterpretInput, type InterpretResult, LENSES, type LensVocabulary, type LifeCapability, type LifeDimension, type ObservedPattern, type OverlapDef, type PatternEvidence, type PatternPersistence, type PrimaryFrame, type PriorRead, RADIANT_PACKAGE_VERSION, type RadiantAI, type RenderInput, type RenderOutput, type RenderingLens, type RepoScope, type Score, type ScoreSentinel, type ScoredObservation, type Signal, type SignalExtractor, type SignalMatrix, type ThinkInput, type ThinkResult, type VoiceDirectives, type VoiceViolation, type WorldmodelItem, auditGovernance, aukiBuilderLens, checkForbiddenPhrases, classifyActorDomain, classifyEvents, composeSystemPrompt, computePersistence, createAnthropicAI, createMockAI, createMockGitHubAdapter, emergent, extractSignals, fetchGitHubActivity, formatExocortexForPrompt, formatPriorReadsForPrompt, formatScope, getLens, interpretPatterns, isPresent, isScored, isSentinel, listLenses, loadPriorReads, parseRepoScope, presenceAverage, readExocortex, render, scoreComposite, scoreCyber, scoreLife, scoreNeuroVerse, summarizeExocortex, think, updateKnowledge, writeRead };