@terminals-tech/sdk 1.0.0-rc.1 → 1.0.0

package/dist/index.d.cts

@@ -1,4 +1,5 @@
 import { JSONSchema7 } from 'json-schema';
+import { Observable } from 'rxjs';
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
 
@@ -549,6 +550,19 @@ interface CoherenceMetrics$1 {
     timestamp: number;
 }
 
+/**
+ * Brain Coherence Module
+ * Metrics for measuring cognitive coherence in agent outputs
+ *
+ * Based on NEURO coherence patterns:
+ * - Grounding: Connection to factual/contextual reality
+ * - Internal: Self-consistency of reasoning
+ * - Crystallization: Clarity and actionability of output
+ *
+ * Heuristic primitives are composed from L1 (core/primitives/coherence-heuristics).
+ * This module adds weights, configuration, explanations, and audio mapping.
+ */
+
 type CoherenceMetrics = CoherenceMetrics$1;
 /**
  * Enhanced coherence result with human-readable explanations
@@ -913,7 +927,7 @@ declare function createDAG<N, E = void>(nodes: DAGNode<N>[], edges: DAGEdge<E>[]
  * @module sdk-types
  */
 
-interface NodePolicy$1 {
+interface NodePolicy {
     fs?: {
         mode?: "sandboxed" | "full";
         allowedPaths?: string[];
@@ -923,7 +937,7 @@ interface NodePolicy$1 {
         allowList?: string[];
     };
 }
-interface StackPolicies$1 {
+interface StackPolicies {
     fs?: {
         mode?: "sandboxed" | "full";
         allowedPaths?: string[];
@@ -1015,7 +1029,7 @@ declare function kuramotoStep(phases: ArrayLike<number>, omega: ArrayLike<number
 /**
  * Signal types for cross-layer communication
  */
-type SignalType = "health_update" | "circuit_change" | "convergence_update" | "coherence_update" | "resonance_update" | "tensor_state_update" | "task_complete" | "task_failed" | "adaptation_required" | "backpressure_warning" | "audio_metrics_update" | "mesh_update" | "mesh_query" | "session_state_change" | "skill_capture_started" | "skill_action_recorded" | "skill_capture_completed" | "skill_crystallized" | "skill_training_started" | "skill_training_completed" | "skill_artifact_activated" | "skill_suggested" | "skill_executed" | "skill_peer_review" | "skill_delegation" | "skill_agent_refine" | "skill_selection" | "skill_backpressure" | "skill_budget_exceeded" | "skill_error" | "interaction_created" | "interaction_status_changed" | "deploy_scaffold" | "deploy_push" | "deploy_build" | "deploy_status" | "deploy_preview" | "deploy_live" | "deploy_error" | "potentiation_rising" | "potentiation_peak" | "potentiation_discharge" | "potentiation_reset" | "action_dispatched" | "action_executed" | "action_failed" | "combo_completed" | "input_surface_changed" | "forge_scene_saved" | "forge_iteration_recorded" | "forge_profile_crystallized" | "forge_profile_requested" | "integration_connected" | "integration_disconnected" | "integration_heartbeat" | "integration_error" | "ui_navigation" | "ui_surface_opened" | "ui_surface_closed" | "ui_interaction" | "ui_error_shown" | "ui_search" | "artifact_preview" | "manifold_node_added" | "manifold_edge_added" | "manifold_query" | "manifold_snapshot" | "connector_status_changed" | "connector_sync_started" | "connector_sync_complete" | "connector_sync_error" | "connector_document_indexed" | "graph_entity_upserted" | "graph_relationship_added" | "graph_traversal_complete" | "intent_signal_emitted" | "oscillator_phase_updated" | "oscillator_suggestion_generated" | "journey_note_created" | "journey_note_deleted" | "journey_edge_created" | "journey_cluster_created" | "journey_replay_entered" | "journey_replay_exited" | "journey_spatial_navigate" | "journey_completed" | "boundary_crossed" | "boundary_sealed" | "convergence_declared" | "convergence_lost" | "crystallization_declared" | "crystallization_melted" | "chat_message_sent" | "chat_message_received" | "chat_error" | "coherence_gate_accepted" | "coherence_gate_rejected" | "manifold_geodesic_computed" | "manifold_distance_measured" | "sematon_created" | "sematon_witnessed" | "sematon_folded" | "sematon_realized" | "sematon_expired";
+type SignalType = "health_update" | "circuit_change" | "convergence_update" | "coherence_update" | "resonance_update" | "tensor_state_update" | "task_complete" | "task_failed" | "adaptation_required" | "backpressure_warning" | "audio_metrics_update" | "mesh_update" | "mesh_query" | "session_state_change" | "skill_capture_started" | "skill_action_recorded" | "skill_capture_completed" | "skill_crystallized" | "skill_training_started" | "skill_training_completed" | "skill_artifact_activated" | "skill_suggested" | "skill_executed" | "skill_peer_review" | "skill_delegation" | "skill_agent_refine" | "skill_selection" | "skill_backpressure" | "skill_budget_exceeded" | "skill_error" | "interaction_created" | "interaction_status_changed" | "deploy_scaffold" | "deploy_push" | "deploy_build" | "deploy_status" | "deploy_preview" | "deploy_live" | "deploy_error" | "potentiation_rising" | "potentiation_peak" | "potentiation_discharge" | "potentiation_reset" | "action_dispatched" | "action_executed" | "action_failed" | "combo_completed" | "input_surface_changed" | "forge_scene_saved" | "forge_iteration_recorded" | "forge_profile_crystallized" | "forge_profile_requested" | "integration_connected" | "integration_disconnected" | "integration_heartbeat" | "integration_error" | "ui_navigation" | "ui_surface_opened" | "ui_surface_closed" | "ui_interaction" | "ui_error_shown" | "ui_search" | "artifact_preview" | "manifold_node_added" | "manifold_edge_added" | "manifold_query" | "manifold_snapshot" | "connector_status_changed" | "connector_sync_started" | "connector_sync_complete" | "connector_sync_error" | "connector_document_indexed" | "graph_entity_upserted" | "graph_relationship_added" | "graph_traversal_complete" | "intent_signal_emitted" | "oscillator_phase_updated" | "oscillator_suggestion_generated" | "journey_note_created" | "journey_note_deleted" | "journey_edge_created" | "journey_cluster_created" | "journey_replay_entered" | "journey_replay_exited" | "journey_spatial_navigate" | "journey_completed" | "boundary_crossed" | "boundary_sealed" | "convergence_declared" | "convergence_lost" | "crystallization_declared" | "crystallization_melted" | "chat_message_sent" | "chat_message_received" | "chat_error" | "coherence_gate_accepted" | "coherence_gate_rejected" | "manifold_geodesic_computed" | "manifold_distance_measured" | "sematon_created" | "sematon_witnessed" | "sematon_folded" | "sematon_realized" | "sematon_expired" | "voice_identity_encoded" | "voice_speaking_started" | "voice_speaking_completed" | "voice_chunk_scheduled" | "voice_coherence_mapped";
 /**
  * Layer-aware signal for AXON cross-layer communication
  */
@@ -1473,1595 +1487,1847 @@ declare function createCircuitBreaker(options: CircuitBreakerOptions): {
     reset(): void;
 };
 
-type NodePolicy = NodePolicy$1;
-type StackPolicies = StackPolicies$1;
 /**
- * Runtime tier for node execution.
+ * Core SDK — Fundamental utilities and data structures
  *
- * Defines the execution environment for computational nodes:
- * - `worker`: Web Worker/service worker
- * - `container-lite`: Lightweight containerized runtime
- * - `webcontainer`: Browser-based container (WebAssembly)
- * - `edge`: Edge function/serverless
- * - `wasm-hvm`: WebAssembly with HVM (Higher-order Virtual Machine)
- * - `stack`: Nested stack execution
+ * Result types, retry/circuit-breaker, event bus, validation, DAG, registry.
+ * Hides internal combinators, vector ops, stream internals.
  *
- * @example
- * const tier: RuntimeTier = "worker";
+ * @copyright © 2026 Intuition Labs LLC. All rights reserved. Patent Pending.
+ * @module sdk/core
  */
-type RuntimeTier = "worker" | "container-lite" | "webcontainer" | "edge" | "wasm-hvm" | "stack";
+
+type core_CircuitBreakerOptions = CircuitBreakerOptions;
+type core_DAG<N, E = void> = DAG<N, E>;
+type core_DAGEdge<E = void> = DAGEdge<E>;
+type core_DAGNode<T> = DAGNode<T>;
+type core_EventHandler<T> = EventHandler<T>;
+type core_Registry<K, V> = Registry<K, V>;
+type core_RetryOptions = RetryOptions;
+type core_SDKResult<T, E = Error> = SDKResult<T, E>;
+type core_StoreError = StoreError;
+type core_TypedEventBus<Events extends Record<string, unknown>> = TypedEventBus<Events>;
+type core_Untrusted<T> = Untrusted<T>;
+type core_Validated<T> = Validated<T>;
+declare const core_createCircuitBreaker: typeof createCircuitBreaker;
+declare const core_createDAG: typeof createDAG;
+declare const core_createEventBus: typeof createEventBus;
+declare const core_createRegistry: typeof createRegistry;
+declare const core_err: typeof err;
+declare const core_isErr: typeof isErr;
+declare const core_isOk: typeof isOk;
+declare const core_ok: typeof ok;
+declare const core_secureValidate: typeof secureValidate;
+declare const core_unbrand: typeof unbrand;
+declare const core_untrusted: typeof untrusted;
+declare const core_validateWithSchema: typeof validateWithSchema;
+declare const core_validated: typeof validated;
+declare const core_withRetry: typeof withRetry;
+declare namespace core {
+  export { type core_CircuitBreakerOptions as CircuitBreakerOptions, type core_DAG as DAG, type core_DAGEdge as DAGEdge, type core_DAGNode as DAGNode, type core_EventHandler as EventHandler, type core_Registry as Registry, type core_RetryOptions as RetryOptions, type core_SDKResult as SDKResult, type core_StoreError as StoreError, type core_TypedEventBus as TypedEventBus, type core_Untrusted as Untrusted, type core_Validated as Validated, core_createCircuitBreaker as createCircuitBreaker, core_createDAG as createDAG, core_createEventBus as createEventBus, core_createRegistry as createRegistry, core_err as err, flatMap as flatMapResult, core_isErr as isErr, core_isOk as isOk, map as mapResult, core_ok as ok, core_secureValidate as secureValidate, core_unbrand as unbrand, core_untrusted as untrusted, core_validateWithSchema as validateWithSchema, core_validated as validated, core_withRetry as withRetry };
+}
+
 /**
- * Secret reference for node execution.
+ * L0 Category Theory Primitives
  *
- * Links a secret from the vault into node environment.
+ * Foundational categorical abstractions for cross-layer type mappings.
+ * Provides the mathematical foundation for isomorphisms between AXON layers.
  *
- * @example
- * const secret: NodeSecretRef = {
- *   name: "api_key",
- *   scope: "stack",
- *   env: "OPENAI_API_KEY",
- *   required: true
- * };
+ * @license BUSL-1.1
+ * @copyright © 2026 Intuition Labs LLC. All rights reserved. Patent Pending.
+ * @module core/L0/category
  */
-interface NodeSecretRef {
-    /** Secret identifier in vault */
-    name: string;
-    /** Resolution scope: node-local or stack-wide */
-    scope: "node" | "stack";
-    /** Environment variable name (defaults to name if omitted) */
-    env?: string;
-    /** Whether secret must exist (default: false) */
-    required?: boolean;
+/**
+ * A morphism is a structure-preserving transformation between types.
+ * This is the fundamental building block of category theory.
+ */
+type Morphism<A, B> = (a: A) => B;
+/**
+ * Async morphism for transformations that may be asynchronous
+ */
+type AsyncMorphism<A, B> = (a: A) => Promise<B>;
+/**
+ * A Category consists of objects and morphisms between them,
+ * with composition and identity laws.
+ */
+interface Category<Obj, Hom> {
+    /** Identity morphism for each object */
+    identity<A extends Obj>(a: A): Hom;
+    /** Composition of morphisms: g . f = g(f(x)) */
+    compose<A extends Obj, B extends Obj, C extends Obj>(f: Hom, g: Hom): Hom;
 }
 /**
- * Runtime-specific entrypoints for node execution.
- *
- * Each runtime tier has its own entrypoint format.
- * At least one entrypoint must be specified.
- *
- * @example
- * const entrypoints: NodeEntrypoints = {
- *   worker: { module: "./transform.js", export: "transform" },
- *   edge: { endpoint: "https://api.example.com/process" }
- * };
+ * An isomorphism is a bijective morphism with an inverse.
+ * For A and B to be isomorphic, there must exist:
+ * - forward: A → B
+ * - backward: B → A
+ * - such that: backward(forward(a)) = a AND forward(backward(b)) = b
  */
-interface NodeEntrypoints {
-    /** Web Worker entrypoint */
-    worker?: {
-        module: string;
-        export?: string;
-    };
-    /** Container-lite entrypoint */
-    "container-lite"?: {
-        command: string;
-        args?: string[];
-        cwd?: string;
-    };
-    /** WebContainer entrypoint */
-    webcontainer?: {
-        command: string;
-        args?: string[];
-        cwd?: string;
-    };
-    /** WASM HVM entrypoint */
-    "wasm-hvm"?: {
-        module: string;
-        function?: string;
-    };
-    /** Edge function entrypoint */
-    edge?: {
-        endpoint: string;
-    };
+interface Iso<A, B> {
+    /** Forward transformation: A → B */
+    forward: Morphism<A, B>;
+    /** Backward transformation: B → A */
+    backward: Morphism<B, A>;
+    /** Optional metadata about the isomorphism */
+    meta?: IsoMeta;
 }
 /**
- * Base manifest fields shared by nodes and stacks.
- *
- * @internal
+ * Metadata about an isomorphism
  */
-interface BaseManifestV0 {
-    /** Unique identifier (must be stable across versions) */
-    id: string;
-    /** Semantic version (e.g., "1.0.0") */
-    version: string;
+interface IsoMeta {
     /** Human-readable name */
     name?: string;
-    /** Description of functionality */
+    /** Description of what this iso does */
     description?: string;
-    /** Security and resource policies */
-    policies?: NodePolicy | StackPolicies;
-    /** Arbitrary metadata for extensions */
-    metadata?: Record<string, unknown>;
+    /** Whether this is an exact isomorphism (no information loss) */
+    exact?: boolean;
+    /** Confidence score for derived isomorphisms (0-1) */
+    confidence?: number;
+    /** Source layer (L1-L5) */
+    sourceLayer?: LayerId;
+    /** Target layer (L1-L5) */
+    targetLayer?: LayerId;
 }
 /**
- * Node manifest for DAG orchestrator.
- *
- * Defines a single computational node in a workflow.
- * Nodes are atomic execution units with typed inputs/outputs.
- *
- * @example
- * const node: NodeManifestV0 = {
- *   id: "llm-transform",
- *   version: "1.0.0",
- *   kind: "transform",
- *   runtimes: ["worker", "edge"],
- *   entrypoints: {
- *     worker: { module: "./llm.js", export: "transform" }
- *   },
- *   inputsSchema: {
- *     type: "object",
- *     properties: {
- *       prompt: { type: "string" }
- *     },
- *     required: ["prompt"]
- *   },
- *   outputsSchema: {
- *     type: "object",
- *     properties: {
- *       text: { type: "string" }
- *     }
- *   }
- * };
+ * Async isomorphism for transformations that may be asynchronous
  */
-interface NodeManifestV0 extends BaseManifestV0 {
-    /** Node type classification */
-    kind: "prompt" | "mcp" | "task" | "transform" | "webhook" | "custom";
-    /** UI label override */
-    label?: string;
-    /** Supported runtime tiers (in priority order) */
-    runtimes: RuntimeTier[];
-    /** Runtime-specific execution entrypoints */
-    entrypoints: NodeEntrypoints;
-    /** JSON Schema for input validation */
-    inputsSchema?: JSONSchema7;
-    /** JSON Schema for output validation */
-    outputsSchema?: JSONSchema7;
-    /** Declared capabilities (e.g., "network", "filesystem") */
-    capabilities?: string[];
-    /** Secret references required by this node */
-    secrets?: NodeSecretRef[];
-    /** Lifecycle hooks for instrumentation */
-    hooks?: {
-        explain?: string;
-        debug?: string;
-        askInput?: string;
-    };
-    /** UI configuration */
-    ui?: {
-        /** Node-specific UI config */
-        config?: unknown;
-        /** Output viewer configuration */
-        viewer?: {
-            kind?: "text" | "table" | "json" | "custom";
-            componentId?: string;
-        };
-    };
-    /** MCP server integration */
-    mcp?: {
-        /** MCP server identifier */
-        server?: string;
-        /** Exposed MCP tools */
-        tools?: Array<{
-            name: string;
-            schema?: JSONSchema7;
-        }>;
-    };
-    /** Observability configuration */
-    observability?: {
-        /** Emit execution logs */
-        emitLogs?: boolean;
-        /** Emit output artifacts */
-        emitArtifacts?: boolean;
-        /** Trace attribute keys to capture */
-        traceAttributes?: string[];
-    };
+interface AsyncIso<A, B> {
+    forward: AsyncMorphism<A, B>;
+    backward: AsyncMorphism<B, A>;
+    meta?: IsoMeta;
 }
 /**
- * Stack-level secret scope definition.
- *
- * Defines which nodes can access a secret.
- *
- * @example
- * const secretScope: StackSecretScope = {
- *   scope: ["fetch-node", "transform-node"],
- *   required: true
- * };
+ * An embedding is a one-way structure-preserving transformation.
+ * Unlike isomorphisms, embeddings may not have a full inverse.
+ * The partial inverse extracts as much as possible from the target type.
  */
-interface StackSecretScope {
-    /** Node IDs that can access this secret */
-    scope: string[];
-    /** Whether secret must exist */
-    required?: boolean;
+interface Embed<A, B> {
+    /** Embed A into B */
+    embed: Morphism<A, B>;
+    /** Partial extraction from B (may lose information) */
+    extract: Morphism<B, Partial<A>>;
+    /** Whether the embedding is lossless */
+    lossless?: boolean;
 }
 /**
- * Stack-level runtime tier configuration.
- *
- * Allows stack-wide defaults with per-node overrides.
- *
- * @example
- * const runtimes: StackRuntimes = {
- *   default: ["worker", "edge"],
- *   overrides: {
- *     "heavy-compute": ["container-lite"]
- *   }
- * };
+ * A functor maps objects and morphisms between categories
+ * while preserving identity and composition.
  */
-interface StackRuntimes {
-    /** Default runtime tiers for all nodes */
-    default?: RuntimeTier[];
-    /** Per-node runtime tier overrides (nodeId -> tiers) */
-    overrides?: Record<string, RuntimeTier[]>;
+interface Functor<F> {
+    /** Map a morphism over the functor */
+    map<A, B>(f: Morphism<A, B>): (fa: F) => F;
 }
 /**
- * Node configuration within a stack.
- *
- * References a node manifest and provides instance-specific config.
- *
- * @example
- * const nodeConfig: StackNodeConfig = {
- *   id: "fetch-1",
- *   nodeRef: "http-fetch",
- *   config: { timeout: 5000 },
- *   runtimes: ["edge"],
- *   secrets: ["api_key"]
- * };
+ * Natural transformation between functors F and G.
+ * For each object A, provides a morphism F(A) → G(A)
+ * such that the naturality square commutes.
  */
-interface StackNodeConfig {
-    /** Unique ID within stack */
-    id: string;
-    /** Reference to NodeManifestV0.id */
-    nodeRef: string;
-    /** Node-specific configuration */
-    config?: Record<string, unknown>;
-    /** Runtime tier override */
-    runtimes?: RuntimeTier[];
-    /** Security policy override */
-    policies?: NodePolicy;
-    /** Secret names from stack.secrets */
-    secrets?: string[];
-}
+type NaturalTransformation<F, G> = <A>(fa: F) => G;
 /**
- * Directed edge connecting two nodes in the stack DAG.
- *
- * Defines data flow from one node's outputs to another's inputs.
- *
- * @example
- * const edge: StackEdge = {
- *   from: "fetch-1",
- *   to: "transform-1",
- *   map: { "data": "input" }
- * };
+ * AXON Layer identifiers
  */
-interface StackEdge {
-    /** Source node ID */
-    from: string;
-    /** Target node ID */
-    to: string;
-    /** Output-to-input key mapping (defaults to identity) */
-    map?: Record<string, string>;
-}
+type LayerId = "L0" | "L1" | "L2" | "L3" | "L4" | "L5";
 /**
- * Manifest layer provenance.
- *
- * - `L0`: Landing/Zero layer (low-level primitives)
- * - `L1`: Compose/Platform layer (higher-level abstractions)
+ * Layer metadata
  */
-type ManifestLayer = "L0" | "L1" | "L2" | "L3" | "L4" | "L5";
-/**
- * Stack manifest for DAG orchestrator.
- *
- * Defines a complete workflow as a directed acyclic graph (DAG) of nodes.
- *
- * @example
- * const stack: StackManifestV0 = {
- *   id: "data-pipeline",
- *   version: "1.0.0",
- *   nodes: [
- *     { id: "fetch", nodeRef: "http-fetch", config: { url: "..." } },
- *     { id: "transform", nodeRef: "llm-transform" }
- *   ],
- *   edges: [
- *     { from: "fetch", to: "transform", map: { data: "input" } }
- *   ],
- *   secrets: {
- *     api_key: { scope: ["fetch"], required: true }
- *   }
- * };
+interface LayerMeta {
+    id: LayerId;
+    name: string;
+    description: string;
+    color: string;
+}
+/**
+ * AXON Layer definitions
  */
-interface StackManifestV0 extends BaseManifestV0 {
-    /** Node instances in this stack */
-    nodes: StackNodeConfig[];
-    /** Edges connecting nodes (data flow) */
-    edges?: StackEdge[];
-    /** Stack-level secret definitions */
-    secrets?: Record<string, StackSecretScope>;
-    /** Runtime tier configuration */
-    runtimes?: StackRuntimes;
-    /** Provenance layer (L0 or L1) */
-    layer?: ManifestLayer;
+declare const LAYERS: Record<LayerId, LayerMeta>;
+/**
+ * Valid layer transitions in the AXON architecture
+ */
+declare const VALID_TRANSITIONS: ReadonlyArray<[LayerId, LayerId]>;
+/**
+ * Product type - categorical product of A and B
+ */
+type Product<A, B> = readonly [A, B];
+/**
+ * Coproduct (sum) type - categorical coproduct of A and B
+ */
+type Coproduct<A, B> = {
+    readonly tag: "left";
+    readonly value: A;
+} | {
+    readonly tag: "right";
+    readonly value: B;
+};
+/**
+ * Create a left-tagged coproduct
+ */
+declare function left<A, B>(value: A): Coproduct<A, B>;
+/**
+ * Create a right-tagged coproduct
+ */
+declare function right<A, B>(value: B): Coproduct<A, B>;
+/**
+ * Fold over a coproduct
+ */
+declare function fold<A, B, C>(onLeft: Morphism<A, C>, onRight: Morphism<B, C>): Morphism<Coproduct<A, B>, C>;
+/**
+ * A proof witness type - represents evidence that P holds
+ */
+type Proof<P> = P extends true ? {
+    readonly _witness: unique symbol;
+} : never;
+/**
+ * A verified value with attached proof
+ */
+interface Verified<T, P> {
+    readonly value: T;
+    readonly proof: Proof<P>;
+}
+/**
+ * Compose two morphisms: g . f
+ */
+declare function compose<A, B, C>(f: Morphism<A, B>, g: Morphism<B, C>): Morphism<A, C>;
+/**
+ * Compose two async morphisms
+ */
+declare function composeAsync<A, B, C>(f: AsyncMorphism<A, B>, g: AsyncMorphism<B, C>): Promise<AsyncMorphism<A, C>>;
+/**
+ * Identity morphism
+ */
+declare function identity<A>(): Morphism<A, A>;
+/**
+ * Compose two isomorphisms
+ */
+declare function composeIso<A, B, C>(iso1: Iso<A, B>, iso2: Iso<B, C>): Iso<A, C>;
+/**
+ * Invert an isomorphism
+ */
+declare function invertIso<A, B>(iso: Iso<A, B>): Iso<B, A>;
+/**
+ * Create an identity isomorphism
+ */
+declare function identityIso<A>(): Iso<A, A>;
+/**
+ * A typed bridge between two layers with verified transition
+ */
+interface LayerBridge<From extends LayerId, To extends LayerId, A, B> {
+    readonly sourceLayer: From;
+    readonly targetLayer: To;
+    readonly iso: Iso<A, B>;
 }
+/**
+ * Check if a layer transition is valid
+ */
+declare function isValidTransition(from: LayerId, to: LayerId): boolean;
+/**
+ * Create a layer bridge (validates transition at runtime)
+ */
+declare function createBridge<From extends LayerId, To extends LayerId, A, B>(from: From, to: To, iso: Iso<A, B>): LayerBridge<From, To, A, B> | null;
 
 /**
- * Skill Manifest Types (L1)
+ * L0 Information Theory Primitives
  *
- * Core types for the Skills Platform. A SkillManifest extends StackManifestV0
- * with skill-specific metadata — a skill IS a stack with agent orchestration.
+ * Provides measures for information preservation, entropy,
+ * and semantic density in cross-layer transformations.
  *
- * @module skills/types
+ * @module core/L0/information
  */
-
-type SkillCategory = "startup" | "legal" | "finance" | "engineering" | "content" | "research" | "operations" | "marketing" | "verification";
-type SkillOutputType = "document" | "website" | "spreadsheet" | "presentation" | "codebase" | "analysis" | "dataset" | "visual" | "video" | "audio" | "composite";
-declare const SKILL_TIERS: readonly ["flagship", "professional", "utility"];
-type SkillTier = (typeof SKILL_TIERS)[number];
-declare const SKILL_RANKS: readonly ["skill", "flow", "fleet", "org", "society"];
-type SkillRank = (typeof SKILL_RANKS)[number];
-/** Effective-dated rank assignment — immutable audit trail */
-interface RankAssignment {
-    /** Current rank */
-    rank: SkillRank;
-    /** ISO 8601 timestamp when this rank became effective */
-    effectiveFrom: string;
-    /** ISO 8601 timestamp when this rank was superseded (null = current) */
-    effectiveTo: string | null;
-    /** Evidence that promotion invariants were satisfied */
-    proof?: PromotionProof;
-}
 /**
- * Promotion proof — the Curry-Howard witness type.
- * Each promotion requires structural evidence that the entity
- * satisfies the invariants of the target rank.
+ * Calculate Shannon entropy for a probability distribution.
+ * H(X) = -Σ p(x) log₂ p(x)
+ *
+ * @param probabilities - Array of probabilities (should sum to 1)
+ * @returns Entropy in bits
  */
-interface PromotionProof {
-    /** Source rank */
-    from: SkillRank;
-    /** Target rank */
-    to: SkillRank;
-    /** Structural invariant checks that passed */
-    invariants: PromotionInvariant[];
-    /** Timestamp of promotion evaluation */
-    evaluatedAt: string;
-    /** Quality score at time of promotion (0-1) */
-    qualityScore: number;
-}
-interface PromotionInvariant {
-    /** Invariant name (e.g., "has_convergence", "has_3_plus_skills", "has_mesh_events") */
-    name: string;
-    /** Whether this invariant was satisfied */
-    satisfied: boolean;
-    /** Human-readable evidence */
-    evidence?: string;
-}
-interface SkillCapabilities {
-    /** Allow image generation via connected media providers */
-    allowImageGen?: boolean;
-    /** Allow video generation via connected media providers */
-    allowVideoGen?: boolean;
-    /** Allow MCP tool access during execution */
-    allowTools?: boolean;
-    /** Allow web search during execution */
-    allowWebSearch?: boolean;
-    /** Allow code execution in sandbox */
-    allowCodeExec?: boolean;
+declare function entropy(probabilities: number[]): number;
+/**
+ * Calculate joint entropy H(X, Y)
+ *
+ * @param jointProbabilities - 2D array of joint probabilities P(X=x, Y=y)
+ * @returns Joint entropy in bits
+ */
+declare function jointEntropy(jointProbabilities: number[][]): number;
+/**
+ * Calculate conditional entropy H(Y|X) = H(X,Y) - H(X)
+ *
+ * @param jointProbabilities - 2D array P(X=x, Y=y)
+ * @returns Conditional entropy in bits
+ */
+declare function conditionalEntropy(jointProbabilities: number[][]): number;
+/**
+ * Calculate mutual information I(X; Y) = H(X) + H(Y) - H(X, Y)
+ * Measures how much knowing one variable reduces uncertainty about the other.
+ *
+ * @param pX - Marginal probability of X
+ * @param pY - Marginal probability of Y
+ * @param pXY - Joint probability P(X, Y) as 2D array
+ * @returns Mutual information in bits
+ */
+declare function mutualInformation(pX: number[], pY: number[], pXY: number[][]): number;
+/**
+ * Metrics for measuring information preservation in transformations
+ */
+interface InformationPreservation {
+    /** Fraction of source information retained (0-1) */
+    retention: number;
+    /** Entropy of the source */
+    sourceEntropy: number;
+    /** Entropy of the target */
+    targetEntropy: number;
+    /** Mutual information between source and target */
+    mutualInfo: number;
+    /** Whether the transformation is lossless */
+    lossless: boolean;
 }
-interface SkillAgent {
-    /** Agent role name (e.g., "Market Researcher", "Legal Analyst") */
-    role: string;
-    /** What this agent does in the workflow */
-    description: string;
-    /** Maps to a NodeManifestV0.id in the stack */
-    nodeRef?: string;
-    /** When true, a synthetic peer reviewer evaluates this agent's output after completion */
-    peerReview?: boolean;
-}
-interface SkillSampleOutput {
-    type: SkillOutputType;
-    title: string;
-    /** Screenshot or live preview URL */
-    previewUrl?: string;
-    description: string;
-}
-/** External service dependency for a skill */
-interface SkillServiceRequirement {
-    /** Unique key for this requirement (e.g., "search", "database", "email") */
-    key: string;
-    /** Human-readable label */
-    label: string;
-    /** Type of service needed */
-    type: "mcp" | "api" | "credential";
-    /** Description of what this service is used for */
-    description: string;
-    /** Whether this service is required or optional */
-    required: boolean;
-    /** Suggested MCP server names (for type: "mcp") */
-    suggestedServers?: string[];
-}
-interface SkillMeta<TInput extends Record<string, unknown> = Record<string, unknown>> {
-    /** Unique skill slug (url-safe) */
-    slug: string;
-    /** Display name */
-    title: string;
-    /** One-line value proposition */
-    tagline: string;
-    /** Detailed description (markdown) */
-    description: string;
-    /** Skill category */
-    category: SkillCategory;
-    /** Skill tier (complexity/impact level) */
-    tier: SkillTier;
-    /** Expected output artifact types */
-    outputs: SkillOutputType[];
-    /** Estimated execution time range in seconds [min, max] */
-    estimatedTime: [number, number];
-    /** Required input schema (JSON Schema) */
-    inputSchema: JSONSchema7;
-    /** Agent roles involved in this skill */
-    agents: SkillAgent[];
-    /** Sample input for demo/preview (typed to match inputSchema) */
-    sampleInput?: TInput;
-    /** Sample output artifacts for showcase */
-    sampleOutputs?: SkillSampleOutput[];
-    /** Tags for filtering */
-    tags: string[];
-    /** Author */
-    author: string;
-    /** Icon identifier (from icon set) */
-    icon?: string;
-    /** Cosmic gradient pair index (0-7 from cosmicGradients) */
-    gradientIndex?: number;
-    /** Output schema for composition chaining (JSON Schema) */
-    outputSchema?: JSONSchema7;
-    /** Allow agents to dynamically delegate tasks to ephemeral agents. Max 2 per run. */
-    allowDelegation?: boolean;
-    /** External service dependencies (MCP servers, APIs, credentials) */
-    services?: SkillServiceRequirement[];
-    /** Runtime capability toggles (image gen, video gen, tools, etc.) */
-    capabilities?: SkillCapabilities;
-    /** Current rank in the hierarchy (default: "skill") */
-    rank?: SkillRank;
-    /** Effective-dated rank history — immutable audit trail */
-    rankHistory?: RankAssignment[];
-    /**
-     * Convergence configuration for iterative agent output refinement.
-     *
-     * Future optimization: the manual convergence loop in runner.ts could be
-     * replaced by `withRetry()` + `withCircuitBreaker()` from
-     * `lib/terminals-tech/core/primitives/middleware` — they provide the same
-     * retry/backoff/threshold semantics with composable middleware chaining.
-     * See also `createRefinementLoop()` from `primitives/refinement` which
-     * encapsulates the score/delta/plateau logic as a standalone primitive.
-     */
-    convergence?: {
-        /** Max refinement iterations per agent. Default 1 (no refinement), max 5. */
-        maxIterations: number;
-        /** Quality threshold (0-1). Agent output must meet this to pass. Default 0.7. */
-        qualityThreshold: number;
-        /** Minimum quality improvement per iteration. Stops early if delta < this. Default 0.05. */
-        minDelta: number;
-        /** Refinement strategy: retry (re-execute), critique (LLM critic), refine (critique + inject feedback). */
-        strategy: "retry" | "critique" | "refine";
-    };
+/**
+ * Measure information preservation between source and transformed representations.
+ * Uses hash-based sampling for large datasets.
+ *
+ * @param source - Original values
+ * @param transformed - Transformed values
+ * @param roundTrip - Optional round-trip values (transformed → source)
+ * @returns Information preservation metrics
+ */
+declare function measurePreservation<S, T>(source: S[], transformed: T[], roundTrip?: S[]): InformationPreservation;
+/**
+ * Semantic density measures bits of meaningful information per token.
+ * Higher density = more information packed into fewer tokens.
+ */
+interface SemanticDensity {
+    /** Total tokens in the representation */
+    tokenCount: number;
+    /** Estimated information content in bits */
+    informationBits: number;
+    /** Bits per token */
+    density: number;
+    /** Compression ratio compared to baseline */
+    compressionRatio: number;
 }
 /**
- * A SkillManifest extends StackManifestV0 with skill-specific metadata.
+ * Calculate semantic density of a representation.
  *
- * This is the core type — a skill IS a stack manifest with agent orchestration
- * metadata. The `skill` field contains all presentation and execution metadata.
+ * @param tokens - Array of tokens (strings, symbols, etc.)
+ * @param baselineTokensPerBit - Baseline tokens per bit of information (default: 2)
+ * @returns Semantic density metrics
+ */
+declare function calculateSemanticDensity(tokens: string[], baselineTokensPerBit?: number): SemanticDensity;
+/**
+ * Estimate Kolmogorov complexity via compression.
+ * Lower complexity = more compressible = more structured.
  *
- * The `TInput` parameter establishes compile-time correspondence between
- * the JSON Schema `inputSchema`, the typed `sampleInput`, and the runtime
- * input validated by `SkillRunner.start()`.
+ * @param data - String representation of data
+ * @returns Estimated complexity as compression ratio
  */
-interface SkillManifest<TInput extends Record<string, unknown> = Record<string, unknown>> extends StackManifestV0 {
-    /** Skill-specific metadata */
-    skill: SkillMeta<TInput>;
-}
-
-type ManifestType = "skill" | "stack" | "node" | "project";
-type ManifestSource = "system" | "user" | "compose" | "marketplace" | "import";
-interface RegistryEntry {
-    type: ManifestType;
-    manifest: SkillManifest | StackManifestV0 | NodeManifestV0 | Record<string, unknown>;
-    source: ManifestSource;
-    registeredAt: number;
-    tags?: string[];
-}
-interface RegistryFilter {
-    type?: ManifestType;
-    source?: ManifestSource;
-    category?: SkillCategory;
-    tags?: string[];
-    limit?: number;
-}
-declare class ManifestRegistry {
-    private entries;
-    register(manifest: SkillManifest | StackManifestV0 | NodeManifestV0 | Record<string, unknown>, type: ManifestType, source: ManifestSource, tags?: string[]): void;
-    get(key: string): RegistryEntry | undefined;
-    getSkill(slug: string): SkillManifest | undefined;
-    getAll(filter?: RegistryFilter): RegistryEntry[];
-    resolve(ref: string): RegistryEntry | null;
-    search(query: string, filter?: RegistryFilter): RegistryEntry[];
-    unregister(key: string): boolean;
-    get size(): number;
-    clear(): void;
-    private deriveKey;
-}
-/** Singleton registry instance */
-declare const registry: ManifestRegistry;
-
+declare function estimateComplexity(data: string): number;
 /**
- * Core SDK — Fundamental utilities and data structures
+ * Calculate KL divergence D_KL(P || Q) = Σ p(x) log(p(x)/q(x))
+ * Measures how much P differs from Q.
  *
- * Result types, retry/circuit-breaker, event bus, validation, DAG, registry.
- * Hides internal combinators, vector ops, stream internals.
+ * @param p - True distribution
+ * @param q - Approximate distribution
+ * @returns KL divergence (non-negative, 0 = identical)
+ */
+declare function klDivergence(p: number[], q: number[]): number;
+/**
+ * Calculate Jensen-Shannon divergence (symmetric KL variant)
+ * JSD(P, Q) = 0.5 * D_KL(P || M) + 0.5 * D_KL(Q || M) where M = 0.5(P + Q)
  *
- * @copyright © 2026 Intuition Labs LLC. All rights reserved. Patent Pending.
- * @module sdk/core
+ * @param p - First distribution
+ * @param q - Second distribution
+ * @returns JS divergence in [0, 1]
  */
-
-type core_CircuitBreakerOptions = CircuitBreakerOptions;
-type core_DAG<N, E = void> = DAG<N, E>;
-type core_DAGEdge<E = void> = DAGEdge<E>;
-type core_DAGNode<T> = DAGNode<T>;
-type core_EventHandler<T> = EventHandler<T>;
-type core_ManifestRegistry = ManifestRegistry;
-declare const core_ManifestRegistry: typeof ManifestRegistry;
-type core_Registry<K, V> = Registry<K, V>;
-type core_RetryOptions = RetryOptions;
-type core_SDKResult<T, E = Error> = SDKResult<T, E>;
-type core_StoreError = StoreError;
-type core_TypedEventBus<Events extends Record<string, unknown>> = TypedEventBus<Events>;
-type core_Untrusted<T> = Untrusted<T>;
-type core_Validated<T> = Validated<T>;
-declare const core_createCircuitBreaker: typeof createCircuitBreaker;
-declare const core_createDAG: typeof createDAG;
-declare const core_createEventBus: typeof createEventBus;
-declare const core_createRegistry: typeof createRegistry;
-declare const core_err: typeof err;
-declare const core_isErr: typeof isErr;
-declare const core_isOk: typeof isOk;
-declare const core_ok: typeof ok;
-declare const core_registry: typeof registry;
-declare const core_secureValidate: typeof secureValidate;
-declare const core_unbrand: typeof unbrand;
-declare const core_untrusted: typeof untrusted;
-declare const core_validateWithSchema: typeof validateWithSchema;
-declare const core_validated: typeof validated;
-declare const core_withRetry: typeof withRetry;
-declare namespace core {
-  export { type core_CircuitBreakerOptions as CircuitBreakerOptions, type core_DAG as DAG, type core_DAGEdge as DAGEdge, type core_DAGNode as DAGNode, type core_EventHandler as EventHandler, core_ManifestRegistry as ManifestRegistry, type core_Registry as Registry, type core_RetryOptions as RetryOptions, type core_SDKResult as SDKResult, type core_StoreError as StoreError, type core_TypedEventBus as TypedEventBus, type core_Untrusted as Untrusted, type core_Validated as Validated, core_createCircuitBreaker as createCircuitBreaker, core_createDAG as createDAG, core_createEventBus as createEventBus, core_createRegistry as createRegistry, core_err as err, flatMap as flatMapResult, core_isErr as isErr, core_isOk as isOk, map as mapResult, core_ok as ok, core_registry as registry, core_secureValidate as secureValidate, core_unbrand as unbrand, core_untrusted as untrusted, core_validateWithSchema as validateWithSchema, core_validated as validated, core_withRetry as withRetry };
-}
+declare function jsDivergence(p: number[], q: number[]): number;
+/**
+ * Normalize an array to sum to 1 (probability distribution)
+ */
+declare function normalize(values: number[]): number[];
+/**
+ * Calculate cosine similarity between two vectors
+ */
+declare function cosineSimilarity(a: number[], b: number[]): number;
 
 /**
- * L0 Category Theory Primitives
+ * L0 Automatic Isomorphism Derivation
  *
- * Foundational categorical abstractions for cross-layer type mappings.
- * Provides the mathematical foundation for isomorphisms between AXON layers.
+ * Automatically derives isomorphisms between compatible types
+ * using structural analysis and field mapping.
  *
  * @license BUSL-1.1
  * @copyright © 2026 Intuition Labs LLC. All rights reserved. Patent Pending.
- * @module core/L0/category
+ * @module core/L0/derivation
  */
+
 /**
- * A morphism is a structure-preserving transformation between types.
- * This is the fundamental building block of category theory.
+ * Type shape descriptor for structural analysis
  */
-type Morphism<A, B> = (a: A) => B;
+interface TypeShape {
+    /** Type kind (object, array, primitive, etc.) */
+    kind: "object" | "array" | "primitive" | "null" | "undefined";
+    /** For objects: map of field name to TypeShape */
+    fields?: Record<string, TypeShape>;
+    /** For arrays: element type shape */
+    elementType?: TypeShape;
+    /** For primitives: the primitive type */
+    primitiveType?: "string" | "number" | "boolean" | "bigint" | "symbol";
+    /** Whether the field is optional */
+    optional?: boolean;
+}
 /**
- * Async morphism for transformations that may be asynchronous
+ * Extract the structural shape of a value at runtime
+ *
+ * @param value - Value to analyze
+ * @returns TypeShape descriptor
  */
-type AsyncMorphism<A, B> = (a: A) => Promise<B>;
+declare function extractShape(value: unknown): TypeShape;
 /**
- * A Category consists of objects and morphisms between them,
- * with composition and identity laws.
+ * Calculate similarity between two type shapes (Jaccard-like)
+ *
+ * @param a - First type shape
+ * @param b - Second type shape
+ * @returns Similarity score (0-1)
  */
-interface Category<Obj, Hom> {
-    /** Identity morphism for each object */
-    identity<A extends Obj>(a: A): Hom;
-    /** Composition of morphisms: g . f = g(f(x)) */
-    compose<A extends Obj, B extends Obj, C extends Obj>(f: Hom, g: Hom): Hom;
+declare function shapeSimilarity(a: TypeShape, b: TypeShape): number;
+/**
+ * A mapping between fields in source and target types
+ */
+interface FieldMapping {
+    /** Source field name */
+    source: string;
+    /** Target field name */
+    target: string;
+    /** Confidence of the mapping (0-1) */
+    confidence: number;
+    /** Transform function if types differ */
+    transform?: Morphism<unknown, unknown>;
 }
 /**
- * An isomorphism is a bijective morphism with an inverse.
- * For A and B to be isomorphic, there must exist:
- * - forward: A → B
- * - backward: B → A
- * - such that: backward(forward(a)) = a AND forward(backward(b)) = b
+ * Derive field mappings between two object shapes
+ *
+ * @param source - Source type shape
+ * @param target - Target type shape
+ * @returns Array of field mappings
  */
-interface Iso<A, B> {
-    /** Forward transformation: A → B */
-    forward: Morphism<A, B>;
-    /** Backward transformation: B → A */
-    backward: Morphism<B, A>;
-    /** Optional metadata about the isomorphism */
-    meta?: IsoMeta;
+declare function deriveFieldMappings(source: TypeShape, target: TypeShape): FieldMapping[];
+/**
+ * Result of automatic isomorphism derivation
+ */
+interface DerivedIso<A, B> extends Iso<A, B> {
+    /** Field mappings used */
+    fieldMappings: FieldMapping[];
+    /** Overall confidence score */
+    confidence: number;
 }
 /**
- * Metadata about an isomorphism
+ * Options for isomorphism derivation
  */
-interface IsoMeta {
-    /** Human-readable name */
-    name?: string;
-    /** Description of what this iso does */
-    description?: string;
-    /** Whether this is an exact isomorphism (no information loss) */
-    exact?: boolean;
-    /** Confidence score for derived isomorphisms (0-1) */
-    confidence?: number;
-    /** Source layer (L1-L5) */
-    sourceLayer?: LayerId;
-    /** Target layer (L1-L5) */
-    targetLayer?: LayerId;
-}
-/**
- * Async isomorphism for transformations that may be asynchronous
- */
-interface AsyncIso<A, B> {
-    forward: AsyncMorphism<A, B>;
-    backward: AsyncMorphism<B, A>;
-    meta?: IsoMeta;
-}
-/**
- * An embedding is a one-way structure-preserving transformation.
- * Unlike isomorphisms, embeddings may not have a full inverse.
- * The partial inverse extracts as much as possible from the target type.
- */
-interface Embed<A, B> {
-    /** Embed A into B */
-    embed: Morphism<A, B>;
-    /** Partial extraction from B (may lose information) */
-    extract: Morphism<B, Partial<A>>;
-    /** Whether the embedding is lossless */
-    lossless?: boolean;
-}
-/**
- * A functor maps objects and morphisms between categories
- * while preserving identity and composition.
- */
-interface Functor<F> {
-    /** Map a morphism over the functor */
-    map<A, B>(f: Morphism<A, B>): (fa: F) => F;
-}
-/**
- * Natural transformation between functors F and G.
- * For each object A, provides a morphism F(A) → G(A)
- * such that the naturality square commutes.
- */
-type NaturalTransformation<F, G> = <A>(fa: F) => G;
-/**
- * AXON Layer identifiers
- */
-type LayerId = "L0" | "L1" | "L2" | "L3" | "L4" | "L5";
-/**
- * Layer metadata
- */
-interface LayerMeta {
-    id: LayerId;
-    name: string;
-    description: string;
-    color: string;
+interface DerivationOptions {
+    /** Minimum confidence threshold (default: 0.5) */
+    minConfidence?: number;
+    /** Whether to include partial mappings (default: true) */
+    includePartial?: boolean;
+    /** Custom field transforms */
+    customTransforms?: Record<string, Morphism<unknown, unknown>>;
 }
 /**
- * AXON Layer definitions
- */
-declare const LAYERS: Record<LayerId, LayerMeta>;
-/**
- * Valid layer transitions in the AXON architecture
+ * Automatically derive an isomorphism between two types based on structure
+ *
+ * @param sampleA - Sample value of type A
+ * @param sampleB - Sample value of type B
+ * @param options - Derivation options
+ * @returns Derived isomorphism or null if not derivable
  */
-declare const VALID_TRANSITIONS: ReadonlyArray<[LayerId, LayerId]>;
+declare function deriveIsomorphism<A extends object, B extends object>(sampleA: A, sampleB: B, options?: DerivationOptions): DerivedIso<A, B> | null;
 /**
- * Product type - categorical product of A and B
+ * Verify an isomorphism by testing round-trip on sample values
+ *
+ * @param iso - Isomorphism to verify
+ * @param samples - Sample values to test
+ * @returns True if all round-trips match
  */
-type Product<A, B> = readonly [A, B];
+declare function verifyIsomorphism<A, B>(iso: Iso<A, B>, samples: A[]): boolean;
 /**
- * Coproduct (sum) type - categorical coproduct of A and B
+ * Check if two types are structurally compatible for isomorphism
+ *
+ * @param shapeA - Source type shape
+ * @param shapeB - Target type shape
+ * @returns Compatibility score (0-1)
  */
-type Coproduct<A, B> = {
-    readonly tag: "left";
-    readonly value: A;
-} | {
-    readonly tag: "right";
-    readonly value: B;
-};
+declare function checkCompatibility(shapeA: TypeShape, shapeB: TypeShape): number;
 /**
- * Create a left-tagged coproduct
+ * Check if a type can be embedded into another (one-way mapping)
+ *
+ * @param source - Source type shape
+ * @param target - Target type shape
+ * @returns True if source can be fully embedded in target
  */
-declare function left<A, B>(value: A): Coproduct<A, B>;
+declare function canEmbed(source: TypeShape, target: TypeShape): boolean;
+
 /**
- * Create a right-tagged coproduct
+ * L0 Sematon — The Smallest Meaning-Bearing Unit
+ *
+ * The sematon is the atomic unit of operational meaning in Terminals OS.
+ * It carries a typed payload, convergence witness, p-adic address,
+ * information-theoretic metrics, and a constructor flag that guarantees
+ * the Deutsch-Marletto invariant: after transforming an input, the
+ * sematon retains the ability to transform again.
+ *
+ * The sematon unifies Signal<T>, ContextNode, FractalSnapshot,
+ * ConvergenceWitness, and CombinatorEvent into a single formal type
+ * at the L0 foundation layer.
+ *
+ * Core Engine Primitive.
+ *
+ * @license BUSL-1.1
+ * @copyright © 2026 Intuition Labs LLC. All rights reserved. Patent Pending.
+ * @module core/L0/sematon
  */
-declare function right<A, B>(value: B): Coproduct<A, B>;
 /**
- * Fold over a coproduct
+ * Payload kind classification for sematons.
+ * Determines how the payload is interpreted across layers.
  */
-declare function fold<A, B, C>(onLeft: Morphism<A, C>, onRight: Morphism<B, C>): Morphism<Coproduct<A, B>, C>;
+type SematonKind = "signal" | "context" | "fractal" | "witness" | "combinator" | "interaction" | "custom";
 /**
- * A proof witness type - represents evidence that P holds
+ * Convergence witness snapshot embedded in a sematon.
+ * Minimal subset of ConvergenceWitness for portability.
  */
-type Proof<P> = P extends true ? {
-    readonly _witness: unique symbol;
-} : never;
+interface SematonWitness {
+    /** Kuramoto order parameter R in [0, 1] */
+    R: number;
+    /** Shannon entropy of activation distribution */
+    activationEntropy: number;
+    /** Whether convergence criteria are met */
+    converged: boolean;
+    /** Step at which this witness was taken */
+    step: number;
+}
 /**
- * A verified value with attached proof
+ * The Sematon — smallest meaning-bearing unit with operational consequence.
+ *
+ * Generic over T (the payload type):
+ *   T = Signal payload at signal kind
+ *   T = ContextNode metadata at context kind
+ *   T = FractalSnapshot at fractal kind
+ *   T = arbitrary at custom kind
  */
-interface Verified<T, P> {
-    readonly value: T;
-    readonly proof: Proof<P>;
+interface Sematon<T = unknown> {
+    /** Unique identifier */
+    readonly id: string;
+    /** Payload kind classification */
+    readonly kind: SematonKind;
+    /** The meaning-bearing payload */
+    readonly payload: T;
+    /** Convergence witness at creation time */
+    readonly witness: SematonWitness;
+    /** p-adic address for hierarchical locality */
+    readonly padicAddress: string;
+    /** Shannon entropy of payload (bits) */
+    readonly entropy: number;
+    /** Semantic density (bits per token) */
+    readonly density: number;
+    /** The resistance to constructive transformation: H / (ρ * R) */
+    readonly impedance: number;
+    /** Deterministic content hash (FNV-1a) */
+    readonly shapeHash: string;
+    /**
+     * Constructor flag: can this sematon participate in further transformations?
+     * True iff: witness has converged AND entropy is finite AND payload is non-empty.
+     * This is the Deutsch-Marletto invariant.
+     */
+    readonly constructive: boolean;
+    /** Creation timestamp */
+    readonly createdAt: number;
+    /** Source layer or surface that produced this sematon */
+    readonly source: string;
 }
 /**
- * Compose two morphisms: g . f
+ * Folded (serializable) representation of a Sematon.
+ * Suitable for JSON serialization, mesh relay, or persistence.
  */
-declare function compose<A, B, C>(f: Morphism<A, B>, g: Morphism<B, C>): Morphism<A, C>;
+interface FoldedSematon {
+    id: string;
+    kind: SematonKind;
+    payload: string;
+    witness: SematonWitness;
+    padicAddress: string;
+    entropy: number;
+    density: number;
+    impedance: number;
+    shapeHash: string;
+    constructive: boolean;
+    createdAt: number;
+    source: string;
+}
+interface SematonConfig<T> {
+    kind: SematonKind;
+    payload: T;
+    witness: SematonWitness;
+    padicAddress?: string;
+    source?: string;
+}
 /**
- * Compose two async morphisms
+ * Create a new Sematon from configuration.
  */
-declare function composeAsync<A, B, C>(f: AsyncMorphism<A, B>, g: AsyncMorphism<B, C>): Promise<AsyncMorphism<A, C>>;
+declare function createSematon<T>(config: SematonConfig<T>): Sematon<T>;
 /**
- * Identity morphism
+ * Get the Shannon entropy of a sematon's payload.
  */
-declare function identity<A>(): Morphism<A, A>;
+declare function sematonEntropy<T>(sematon: Sematon<T>): number;
 /**
- * Compose two isomorphisms
+ * Get the semantic density of a sematon.
  */
-declare function composeIso<A, B, C>(iso1: Iso<A, B>, iso2: Iso<B, C>): Iso<A, C>;
+declare function sematonDensity<T>(sematon: Sematon<T>): number;
 /**
- * Invert an isomorphism
+ * Check if a sematon can participate in further transformations.
+ * This is the Deutsch-Marletto constructor invariant.
  */
-declare function invertIso<A, B>(iso: Iso<A, B>): Iso<B, A>;
+declare function isRealizable<T>(sematon: Sematon<T>): boolean;
 /**
- * Create an identity isomorphism
+ * Compute distance between two sematons using payload cosine similarity
+ * weighted by witness R proximity.
+ *
+ * Distance in [0, 1] where 0 = identical, 1 = maximally different.
  */
-declare function identityIso<A>(): Iso<A, A>;
+declare function sematonDistance<T>(a: Sematon<T>, b: Sematon<T>): number;
 /**
- * A typed bridge between two layers with verified transition
+ * Fold a Sematon into a JSON-serializable representation.
+ * HVM γ (construct) — compress for handoff, persistence, or relay.
  */
-interface LayerBridge<From extends LayerId, To extends LayerId, A, B> {
-    readonly sourceLayer: From;
-    readonly targetLayer: To;
-    readonly iso: Iso<A, B>;
-}
+declare function foldSematon<T>(sematon: Sematon<T>): FoldedSematon;
 /**
- * Check if a layer transition is valid
+ * Unfold a serialized representation back into a Sematon.
+ * HVM δ (duplicate) — expand from handoff, persistence, or relay.
  */
-declare function isValidTransition(from: LayerId, to: LayerId): boolean;
+declare function unfoldSematon<T>(folded: FoldedSematon): Sematon<T>;
+
 /**
- * Create a layer bridge (validates transition at runtime)
- */
-declare function createBridge<From extends LayerId, To extends LayerId, A, B>(from: From, to: To, iso: Iso<A, B>): LayerBridge<From, To, A, B> | null;
-
-/**
- * L0 Information Theory Primitives
- *
- * Provides measures for information preservation, entropy,
- * and semantic density in cross-layer transformations.
- *
- * @module core/L0/information
- */
-/**
- * Calculate Shannon entropy for a probability distribution.
- * H(X) = -Σ p(x) log₂ p(x)
+ * L0 Realizability Trace — Constructor Proof Runtime
  *
- * @param probabilities - Array of probabilities (should sum to 1)
- * @returns Entropy in bits
- */
-declare function entropy(probabilities: number[]): number;
-/**
- * Calculate joint entropy H(X, Y)
+ * A RealizabilityTrace is an ordered sequence of RealizabilitySteps.
+ * Each step records: input Sematon(s), output Sematon(s), a ConvergenceWitness
+ * snapshot, and information gain.
  *
- * @param jointProbabilities - 2D array of joint probabilities P(X=x, Y=y)
- * @returns Joint entropy in bits
- */
-declare function jointEntropy(jointProbabilities: number[][]): number;
-/**
- * Calculate conditional entropy H(Y|X) = H(X,Y) - H(X)
+ * verifyTrace() checks three constructor invariants:
+ *   1. Each input was realizable (constructive flag true)
+ *   2. Each witness converged (R above threshold)
+ *   3. Information is non-decreasing across steps
  *
- * @param jointProbabilities - 2D array P(X=x, Y=y)
- * @returns Conditional entropy in bits
- */
-declare function conditionalEntropy(jointProbabilities: number[][]): number;
-/**
- * Calculate mutual information I(X; Y) = H(X) + H(Y) - H(X, Y)
- * Measures how much knowing one variable reduces uncertainty about the other.
+ * This is the Deutsch-Marletto constructor invariant made executable:
+ * after transforming inputs, the system retains the ability to transform again.
  *
- * @param pX - Marginal probability of X
- * @param pY - Marginal probability of Y
- * @param pXY - Joint probability P(X, Y) as 2D array
- * @returns Mutual information in bits
- */
-declare function mutualInformation(pX: number[], pY: number[], pXY: number[][]): number;
-/**
- * Metrics for measuring information preservation in transformations
+ * @license BUSL-1.1
+ * @copyright © 2026 Intuition Labs LLC. All rights reserved. Patent Pending.
+ * @module core/L0/realizability
  */
-interface InformationPreservation {
-    /** Fraction of source information retained (0-1) */
-    retention: number;
-    /** Entropy of the source */
-    sourceEntropy: number;
-    /** Entropy of the target */
-    targetEntropy: number;
-    /** Mutual information between source and target */
-    mutualInfo: number;
-    /** Whether the transformation is lossless */
-    lossless: boolean;
+
+interface RealizabilityStep {
+    /** Step index in the trace */
+    index: number;
+    /** Input sematons consumed by this step */
+    inputs: Sematon[];
+    /** Output sematons produced by this step */
+    outputs: Sematon[];
+    /** Convergence witness at this step */
+    witness: SematonWitness;
+    /** Total information content of outputs (bits) */
+    informationGain: number;
+    /** Timestamp */
+    timestamp: number;
 }
-/**
- * Measure information preservation between source and transformed representations.
- * Uses hash-based sampling for large datasets.
- *
- * @param source - Original values
- * @param transformed - Transformed values
- * @param roundTrip - Optional round-trip values (transformed → source)
- * @returns Information preservation metrics
- */
-declare function measurePreservation<S, T>(source: S[], transformed: T[], roundTrip?: S[]): InformationPreservation;
-/**
- * Semantic density measures bits of meaningful information per token.
- * Higher density = more information packed into fewer tokens.
- */
-interface SemanticDensity {
-    /** Total tokens in the representation */
-    tokenCount: number;
-    /** Estimated information content in bits */
-    informationBits: number;
-    /** Bits per token */
-    density: number;
-    /** Compression ratio compared to baseline */
-    compressionRatio: number;
+interface RealizabilityTrace {
+    /** Unique trace identifier */
+    id: string;
+    /** Ordered sequence of steps */
+    steps: RealizabilityStep[];
+    /** Whether the trace has been verified */
+    verified: boolean;
+    /** Total information gain across all steps */
+    totalInfoGain: number;
+    /** Count of constructive (realizable) steps */
+    constructiveSteps: number;
+    /** Creation timestamp */
+    createdAt: number;
 }
+interface VerificationSuccess {
+    valid: true;
+    totalInfoGain: number;
+    constructiveSteps: number;
+}
+interface VerificationFailure {
+    valid: false;
+    failureStep: number;
+    reason: string;
+}
+type VerificationResult = VerificationSuccess | VerificationFailure;
 /**
- * Calculate semantic density of a representation.
- *
- * @param tokens - Array of tokens (strings, symbols, etc.)
- * @param baselineTokensPerBit - Baseline tokens per bit of information (default: 2)
- * @returns Semantic density metrics
- */
-declare function calculateSemanticDensity(tokens: string[], baselineTokensPerBit?: number): SemanticDensity;
-/**
- * Estimate Kolmogorov complexity via compression.
- * Lower complexity = more compressible = more structured.
- *
- * @param data - String representation of data
- * @returns Estimated complexity as compression ratio
+ * Create a single realizability step.
+ * Computes informationGain as the sum of output sematon entropies.
  */
-declare function estimateComplexity(data: string): number;
+declare function createRealizabilityStep(index: number, inputs: Sematon[], outputs: Sematon[], witness: SematonWitness): RealizabilityStep;
 /**
- * Calculate KL divergence D_KL(P || Q) = Σ p(x) log(p(x)/q(x))
- * Measures how much P differs from Q.
- *
- * @param p - True distribution
- * @param q - Approximate distribution
- * @returns KL divergence (non-negative, 0 = identical)
+ * Construct a RealizabilityTrace from an ordered sequence of steps.
+ * Computes totalInfoGain and constructiveSteps.
  */
-declare function klDivergence(p: number[], q: number[]): number;
+declare function traceRealizability(steps: RealizabilityStep[]): RealizabilityTrace;
 /**
- * Calculate Jensen-Shannon divergence (symmetric KL variant)
- * JSD(P, Q) = 0.5 * D_KL(P || M) + 0.5 * D_KL(Q || M) where M = 0.5(P + Q)
+ * Verify a realizability trace against three constructor invariants:
+ *   1. Each step's inputs must all be realizable
+ *   2. Each step's witness must have converged
+ *   3. Information is non-decreasing across steps
  *
- * @param p - First distribution
- * @param q - Second distribution
- * @returns JS divergence in [0, 1]
+ * Returns VerificationSuccess or VerificationFailure with step index and reason.
  */
-declare function jsDivergence(p: number[], q: number[]): number;
+declare function verifyTrace(trace: RealizabilityTrace): VerificationResult;
 /**
- * Normalize an array to sum to 1 (probability distribution)
+ * Fold a RealizabilityTrace into a JSON string.
+ * Sematons are folded via foldSematon first for portable serialization.
  */
-declare function normalize(values: number[]): number[];
+declare function foldTrace(trace: RealizabilityTrace): string;
 /**
- * Calculate cosine similarity between two vectors
+ * Unfold a JSON string back into a RealizabilityTrace.
+ * Sematons are unfolded via unfoldSematon.
  */
-declare function cosineSimilarity(a: number[], b: number[]): number;
+declare function unfoldTrace(json: string): RealizabilityTrace;
 
 /**
- * L0 Automatic Isomorphism Derivation
+ * L0 Foundation Layer
  *
- * Automatically derives isomorphisms between compatible types
- * using structural analysis and field mapping.
+ * Provides categorical foundations and information-theoretic primitives
+ * for cross-layer mappings in the AXON architecture.
  *
- * @license BUSL-1.1
- * @copyright © 2026 Intuition Labs LLC. All rights reserved. Patent Pending.
- * @module core/L0/derivation
+ * @module core/L0
  */
 
-/**
- * Type shape descriptor for structural analysis
- */
-interface TypeShape {
-    /** Type kind (object, array, primitive, etc.) */
-    kind: "object" | "array" | "primitive" | "null" | "undefined";
-    /** For objects: map of field name to TypeShape */
-    fields?: Record<string, TypeShape>;
-    /** For arrays: element type shape */
-    elementType?: TypeShape;
-    /** For primitives: the primitive type */
-    primitiveType?: "string" | "number" | "boolean" | "bigint" | "symbol";
-    /** Whether the field is optional */
-    optional?: boolean;
+type index_AsyncIso<A, B> = AsyncIso<A, B>;
+type index_AsyncMorphism<A, B> = AsyncMorphism<A, B>;
+type index_Category<Obj, Hom> = Category<Obj, Hom>;
+type index_Coproduct<A, B> = Coproduct<A, B>;
+type index_DerivationOptions = DerivationOptions;
+type index_DerivedIso<A, B> = DerivedIso<A, B>;
+type index_Embed<A, B> = Embed<A, B>;
+type index_FieldMapping = FieldMapping;
+type index_FoldedSematon = FoldedSematon;
+type index_Functor<F> = Functor<F>;
+type index_InformationPreservation = InformationPreservation;
+type index_Iso<A, B> = Iso<A, B>;
+type index_IsoMeta = IsoMeta;
+declare const index_LAYERS: typeof LAYERS;
+type index_LayerBridge<From extends LayerId, To extends LayerId, A, B> = LayerBridge<From, To, A, B>;
+type index_LayerId = LayerId;
+type index_LayerMeta = LayerMeta;
+type index_Morphism<A, B> = Morphism<A, B>;
+type index_NaturalTransformation<F, G> = NaturalTransformation<F, G>;
+type index_Product<A, B> = Product<A, B>;
+type index_Proof<P> = Proof<P>;
+type index_RealizabilityStep = RealizabilityStep;
+type index_RealizabilityTrace = RealizabilityTrace;
+type index_SemanticDensity = SemanticDensity;
+type index_Sematon<T = unknown> = Sematon<T>;
+type index_SematonConfig<T> = SematonConfig<T>;
+type index_SematonKind = SematonKind;
+type index_SematonWitness = SematonWitness;
+type index_TypeShape = TypeShape;
+declare const index_VALID_TRANSITIONS: typeof VALID_TRANSITIONS;
+type index_VerificationFailure = VerificationFailure;
+type index_VerificationResult = VerificationResult;
+type index_VerificationSuccess = VerificationSuccess;
+type index_Verified<T, P> = Verified<T, P>;
+declare const index_calculateSemanticDensity: typeof calculateSemanticDensity;
+declare const index_canEmbed: typeof canEmbed;
+declare const index_checkCompatibility: typeof checkCompatibility;
+declare const index_compose: typeof compose;
+declare const index_composeAsync: typeof composeAsync;
+declare const index_composeIso: typeof composeIso;
+declare const index_conditionalEntropy: typeof conditionalEntropy;
+declare const index_cosineSimilarity: typeof cosineSimilarity;
+declare const index_createBridge: typeof createBridge;
+declare const index_createRealizabilityStep: typeof createRealizabilityStep;
+declare const index_createSematon: typeof createSematon;
+declare const index_deriveFieldMappings: typeof deriveFieldMappings;
+declare const index_deriveIsomorphism: typeof deriveIsomorphism;
+declare const index_entropy: typeof entropy;
+declare const index_estimateComplexity: typeof estimateComplexity;
+declare const index_extractShape: typeof extractShape;
+declare const index_fold: typeof fold;
+declare const index_foldSematon: typeof foldSematon;
+declare const index_foldTrace: typeof foldTrace;
+declare const index_identity: typeof identity;
+declare const index_identityIso: typeof identityIso;
+declare const index_invertIso: typeof invertIso;
+declare const index_isRealizable: typeof isRealizable;
+declare const index_isValidTransition: typeof isValidTransition;
+declare const index_jointEntropy: typeof jointEntropy;
+declare const index_jsDivergence: typeof jsDivergence;
+declare const index_klDivergence: typeof klDivergence;
+declare const index_left: typeof left;
+declare const index_measurePreservation: typeof measurePreservation;
+declare const index_mutualInformation: typeof mutualInformation;
+declare const index_normalize: typeof normalize;
+declare const index_right: typeof right;
+declare const index_sematonDensity: typeof sematonDensity;
+declare const index_sematonDistance: typeof sematonDistance;
+declare const index_sematonEntropy: typeof sematonEntropy;
+declare const index_shapeSimilarity: typeof shapeSimilarity;
+declare const index_traceRealizability: typeof traceRealizability;
+declare const index_unfoldSematon: typeof unfoldSematon;
+declare const index_unfoldTrace: typeof unfoldTrace;
+declare const index_verifyIsomorphism: typeof verifyIsomorphism;
+declare const index_verifyTrace: typeof verifyTrace;
+declare namespace index {
+  export { type index_AsyncIso as AsyncIso, type index_AsyncMorphism as AsyncMorphism, type index_Category as Category, type index_Coproduct as Coproduct, type index_DerivationOptions as DerivationOptions, type index_DerivedIso as DerivedIso, type index_Embed as Embed, type index_FieldMapping as FieldMapping, type index_FoldedSematon as FoldedSematon, type index_Functor as Functor, type index_InformationPreservation as InformationPreservation, type index_Iso as Iso, type index_IsoMeta as IsoMeta, index_LAYERS as LAYERS, type index_LayerBridge as LayerBridge, type index_LayerId as LayerId, type index_LayerMeta as LayerMeta, type index_Morphism as Morphism, type index_NaturalTransformation as NaturalTransformation, type index_Product as Product, type index_Proof as Proof, type index_RealizabilityStep as RealizabilityStep, type index_RealizabilityTrace as RealizabilityTrace, type index_SemanticDensity as SemanticDensity, type index_Sematon as Sematon, type index_SematonConfig as SematonConfig, type index_SematonKind as SematonKind, type index_SematonWitness as SematonWitness, type index_TypeShape as TypeShape, index_VALID_TRANSITIONS as VALID_TRANSITIONS, type index_VerificationFailure as VerificationFailure, type index_VerificationResult as VerificationResult, type index_VerificationSuccess as VerificationSuccess, type index_Verified as Verified, index_calculateSemanticDensity as calculateSemanticDensity, index_canEmbed as canEmbed, index_checkCompatibility as checkCompatibility, index_compose as compose, index_composeAsync as composeAsync, index_composeIso as composeIso, index_conditionalEntropy as conditionalEntropy, index_cosineSimilarity as cosineSimilarity, index_createBridge as createBridge, index_createRealizabilityStep as createRealizabilityStep, index_createSematon as createSematon, index_deriveFieldMappings as deriveFieldMappings, index_deriveIsomorphism as deriveIsomorphism, index_entropy as entropy, index_estimateComplexity as estimateComplexity, index_extractShape as extractShape, index_fold as fold, index_foldSematon as foldSematon, index_foldTrace as foldTrace, index_identity as identity, index_identityIso as identityIso, index_invertIso as invertIso, index_isRealizable as isRealizable, index_isValidTransition as isValidTransition, index_jointEntropy as jointEntropy, index_jsDivergence as jsDivergence, index_klDivergence as klDivergence, index_left as left, index_measurePreservation as measurePreservation, index_mutualInformation as mutualInformation, index_normalize as normalize, index_right as right, index_sematonDensity as sematonDensity, index_sematonDistance as sematonDistance, index_sematonEntropy as sematonEntropy, index_shapeSimilarity as shapeSimilarity, index_traceRealizability as traceRealizability, index_unfoldSematon as unfoldSematon, index_unfoldTrace as unfoldTrace, index_verifyIsomorphism as verifyIsomorphism, index_verifyTrace as verifyTrace };
 }
+
 /**
- * Extract the structural shape of a value at runtime
+ * Action Algebra — Input-Agnostic Action Types
  *
- * @param value - Value to analyze
- * @returns TypeShape descriptor
- */
-declare function extractShape(value: unknown): TypeShape;
-/**
- * Calculate similarity between two type shapes (Jaccard-like)
+ * All input surfaces (keyboard, gamepad, voice, touch) compile down to this algebra.
+ * All executors interpret this algebra into effects.
  *
- * @param a - First type shape
- * @param b - Second type shape
- * @returns Similarity score (0-1)
- */
-declare function shapeSimilarity(a: TypeShape, b: TypeShape): number;
-/**
- * A mapping between fields in source and target types
+ * @module core/primitives/action
  */
-interface FieldMapping {
-    /** Source field name */
-    source: string;
-    /** Target field name */
-    target: string;
-    /** Confidence of the mapping (0-1) */
-    confidence: number;
-    /** Transform function if types differ */
-    transform?: Morphism<unknown, unknown>;
+
+type NavigationTarget = {
+    kind: "surface";
+    surface: SurfaceId;
+} | {
+    kind: "tab";
+    tab: string;
+} | {
+    kind: "route";
+    path: string;
+    params?: Record<string, string>;
+} | {
+    kind: "focus";
+    elementId: string;
+} | {
+    kind: "relative";
+    direction: "up" | "down" | "left" | "right";
+};
+type SkillRef = {
+    kind: "slug";
+    slug: string;
+} | {
+    kind: "id";
+    id: string;
+} | {
+    kind: "command";
+    commandId: string;
+};
+interface ComposeEdge {
+    sourceId: string;
+    targetId: string;
+    port?: string;
 }
-/**
- * Derive field mappings between two object shapes
- *
- * @param source - Source type shape
- * @param target - Target type shape
- * @returns Array of field mappings
- */
-declare function deriveFieldMappings(source: TypeShape, target: TypeShape): FieldMapping[];
-/**
- * Result of automatic isomorphism derivation
- */
-interface DerivedIso<A, B> extends Iso<A, B> {
-    /** Field mappings used */
-    fieldMappings: FieldMapping[];
-    /** Overall confidence score */
-    confidence: number;
+type ObserveTarget = {
+    kind: "metric";
+    metricId: string;
+} | {
+    kind: "panel";
+    panelId: string;
+} | {
+    kind: "surface";
+    surface: SurfaceId;
+};
+interface DelegateAssignment {
+    agentId: string;
+    taskDescription: string;
+    context?: Record<string, unknown>;
 }
-/**
- * Options for isomorphism derivation
- */
-interface DerivationOptions {
-    /** Minimum confidence threshold (default: 0.5) */
-    minConfidence?: number;
-    /** Whether to include partial mappings (default: true) */
-    includePartial?: boolean;
-    /** Custom field transforms */
-    customTransforms?: Record<string, Morphism<unknown, unknown>>;
+type Action = {
+    verb: "navigate";
+    target: NavigationTarget;
+} | {
+    verb: "execute";
+    skill: SkillRef;
+    args?: Record<string, unknown>;
+} | {
+    verb: "compose";
+    edge: ComposeEdge;
+} | {
+    verb: "observe";
+    target: ObserveTarget;
+    zoom?: number;
+} | {
+    verb: "delegate";
+    assignment: DelegateAssignment;
+} | {
+    verb: "palette";
+    query?: string;
+} | {
+    verb: "cancel";
+} | {
+    verb: "undo";
+} | {
+    verb: "redo";
+} | {
+    verb: "sequence";
+    actions: Action[];
+};
+type InputSurface = "keyboard" | "gamepad" | "voice" | "touch" | "command_palette";
+interface ActionEvent {
+    action: Action;
+    source: InputSurface;
+    timestamp: number;
+    inputTrace?: string[];
+}
+interface ActionContext {
+    activeSurface: SurfaceId;
+    activeTab: string;
+    selection: string[];
+    isTextFocused: boolean;
+    isModalOpen: boolean;
+}
+type ActionPredicate = (ctx: ActionContext) => boolean;
+interface KeyboardTrigger {
+    type: "chord" | "key" | "sequence";
+    keys: string[];
+    timeout?: number;
+}
+type GamepadButton = "a" | "b" | "x" | "y" | "lb" | "rb" | "lt" | "rt" | "back" | "start" | "ls" | "rs" | "dpad_up" | "dpad_down" | "dpad_left" | "dpad_right";
+interface GamepadTrigger {
+    type: "button" | "combo" | "axis";
+    buttons?: GamepadButton[];
+    sequence?: {
+        button: GamepadButton;
+        holdMs?: number;
+    }[];
+    axis?: {
+        stick: "left" | "right";
+        direction: "up" | "down" | "left" | "right";
+        threshold?: number;
+    };
+}
+interface VoiceTrigger {
+    type: "intent";
+    patterns: string[];
+    confidenceThreshold?: number;
+}
+interface TouchTrigger {
+    type: "gesture";
+    gesture: "swipe_left" | "swipe_right" | "swipe_up" | "swipe_down" | "pinch_in" | "pinch_out" | "long_press" | "double_tap" | "three_finger_swipe";
+}
+type InputTrigger = KeyboardTrigger | GamepadTrigger | VoiceTrigger | TouchTrigger;
+interface ActionBinding {
+    id: string;
+    action: Action;
+    label: string;
+    category: string;
+    when: ActionPredicate;
+    trigger: InputTrigger;
+    surface: InputSurface;
 }
+/** Sequence two actions (flattens nested sequences) */
+declare function seq(a: Action, b: Action): Action;
+/** Navigate then execute */
+declare function goAndRun(target: NavigationTarget, skill: SkillRef): Action;
+/** Delegate then observe */
+declare function delegateAndWatch(assignment: DelegateAssignment, metric: ObserveTarget): Action;
+
 /**
- * Automatically derive an isomorphism between two types based on structure
- *
- * @param sampleA - Sample value of type A
- * @param sampleB - Sample value of type B
- * @param options - Derivation options
- * @returns Derived isomorphism or null if not derivable
- */
-declare function deriveIsomorphism<A extends object, B extends object>(sampleA: A, sampleB: B, options?: DerivationOptions): DerivedIso<A, B> | null;
-/**
- * Verify an isomorphism by testing round-trip on sample values
- *
- * @param iso - Isomorphism to verify
- * @param samples - Sample values to test
- * @returns True if all round-trips match
- */
-declare function verifyIsomorphism<A, B>(iso: Iso<A, B>, samples: A[]): boolean;
-/**
- * Check if two types are structurally compatible for isomorphism
+ * ActionBus — Singleton event bus for the Action Algebra
  *
- * @param shapeA - Source type shape
- * @param shapeB - Target type shape
- * @returns Compatibility score (0-1)
- */
-declare function checkCompatibility(shapeA: TypeShape, shapeB: TypeShape): number;
-/**
- * Check if a type can be embedded into another (one-way mapping)
+ * All input surfaces publish ActionEvents here.
+ * The executor and any observers subscribe here.
  *
- * @param source - Source type shape
- * @param target - Target type shape
- * @returns True if source can be fully embedded in target
+ * @module core/primitives/action-bus
  */
-declare function canEmbed(source: TypeShape, target: TypeShape): boolean;
+
+type ActionBusEvents = {
+    "action:dispatched": ActionEvent;
+    "action:executed": ActionEvent & {
+        result: "success" | "error";
+        error?: string;
+    };
+    "action:cancelled": {
+        reason: string;
+        timestamp: number;
+    };
+    "context:changed": ActionContext;
+};
+declare function getActionBus(): TypedEventBus<ActionBusEvents>;
+declare function dispatchAction(event: ActionEvent): void;
+declare function onAction(handler: (event: ActionEvent) => void): () => void;
 
 /**
- * L0 Sematon — The Smallest Meaning-Bearing Unit
- *
- * The sematon is the atomic unit of operational meaning in Terminals OS.
- * It carries a typed payload, convergence witness, p-adic address,
- * information-theoretic metrics, and a constructor flag that guarantees
- * the Deutsch-Marletto invariant: after transforming an input, the
- * sematon retains the ability to transform again.
- *
- * The sematon unifies Signal<T>, ContextNode, FractalSnapshot,
- * ConvergenceWitness, and CombinatorEvent into a single formal type
- * at the L0 foundation layer.
+ * Mesh SDK — Event emission, subscription, and query
  *
- * Core Engine Primitive.
+ * Cross-layer communication via signals and the action bus.
+ * Hides Interaction primitive internals, SDKMessage, AXON internals.
  *
- * @license BUSL-1.1
  * @copyright © 2026 Intuition Labs LLC. All rights reserved. Patent Pending.
- * @module core/L0/sematon
- */
-/**
- * Payload kind classification for sematons.
- * Determines how the payload is interpreted across layers.
- */
-type SematonKind = "signal" | "context" | "fractal" | "witness" | "combinator" | "interaction" | "custom";
-/**
- * Convergence witness snapshot embedded in a sematon.
- * Minimal subset of ConvergenceWitness for portability.
+ * @module sdk/mesh
  */
-interface SematonWitness {
-    /** Kuramoto order parameter R in [0, 1] */
-    R: number;
-    /** Shannon entropy of activation distribution */
-    activationEntropy: number;
-    /** Whether convergence criteria are met */
-    converged: boolean;
-    /** Step at which this witness was taken */
-    step: number;
+
+type mesh_Action = Action;
+type mesh_ActionBinding = ActionBinding;
+type mesh_ActionBusEvents = ActionBusEvents;
+type mesh_ActionContext = ActionContext;
+type mesh_ActionEvent = ActionEvent;
+type mesh_InputSurface = InputSurface;
+type mesh_Signal<T = unknown> = Signal<T>;
+type mesh_SignalBus = SignalBus;
+type mesh_SignalHandler<T = unknown> = SignalHandler<T>;
+type mesh_SignalType = SignalType;
+declare const mesh_createSignalBus: typeof createSignalBus;
+declare const mesh_delegateAndWatch: typeof delegateAndWatch;
+declare const mesh_dispatchAction: typeof dispatchAction;
+declare const mesh_emitSignal: typeof emitSignal;
+declare const mesh_getActionBus: typeof getActionBus;
+declare const mesh_getSignalBus: typeof getSignalBus;
+declare const mesh_goAndRun: typeof goAndRun;
+declare const mesh_onAction: typeof onAction;
+declare const mesh_seq: typeof seq;
+declare const mesh_subscribeToSignals: typeof subscribeToSignals;
+declare namespace mesh {
+  export { type mesh_Action as Action, type mesh_ActionBinding as ActionBinding, type mesh_ActionBusEvents as ActionBusEvents, type mesh_ActionContext as ActionContext, type mesh_ActionEvent as ActionEvent, type mesh_InputSurface as InputSurface, type mesh_Signal as Signal, type mesh_SignalBus as SignalBus, type mesh_SignalHandler as SignalHandler, type mesh_SignalType as SignalType, mesh_createSignalBus as createSignalBus, mesh_delegateAndWatch as delegateAndWatch, mesh_dispatchAction as dispatchAction, mesh_emitSignal as emitSignal, mesh_getActionBus as getActionBus, mesh_getSignalBus as getSignalBus, mesh_goAndRun as goAndRun, mesh_onAction as onAction, mesh_seq as seq, mesh_subscribeToSignals as subscribeToSignals };
 }
-/**
- * The Sematon — smallest meaning-bearing unit with operational consequence.
- *
- * Generic over T (the payload type):
- *   T = Signal payload at signal kind
- *   T = ContextNode metadata at context kind
- *   T = FractalSnapshot at fractal kind
- *   T = arbitrary at custom kind
- */
-interface Sematon<T = unknown> {
-    /** Unique identifier */
-    readonly id: string;
-    /** Payload kind classification */
-    readonly kind: SematonKind;
-    /** The meaning-bearing payload */
-    readonly payload: T;
-    /** Convergence witness at creation time */
-    readonly witness: SematonWitness;
-    /** p-adic address for hierarchical locality */
-    readonly padicAddress: string;
-    /** Shannon entropy of payload (bits) */
-    readonly entropy: number;
-    /** Semantic density (bits per token) */
-    readonly density: number;
-    /** The resistance to constructive transformation: H / (ρ * R) */
-    readonly impedance: number;
-    /** Deterministic content hash (FNV-1a) */
-    readonly shapeHash: string;
-    /**
-     * Constructor flag: can this sematon participate in further transformations?
-     * True iff: witness has converged AND entropy is finite AND payload is non-empty.
-     * This is the Deutsch-Marletto invariant.
-     */
-    readonly constructive: boolean;
-    /** Creation timestamp */
-    readonly createdAt: number;
-    /** Source layer or surface that produced this sematon */
-    readonly source: string;
+
+type brain_CoherenceConfig = CoherenceConfig;
+type brain_CoherenceInput = CoherenceInput;
+type brain_CoherenceMetrics = CoherenceMetrics;
+type brain_CoherenceResult = CoherenceResult;
+type brain_KuramotoStepOptions = KuramotoStepOptions;
+type brain_OrderParameter = OrderParameter;
+declare const brain_calculateCoherence: typeof calculateCoherence;
+declare const brain_calculateCoherenceWithExplanations: typeof calculateCoherenceWithExplanations;
+declare const brain_getCoherenceSuggestions: typeof getCoherenceSuggestions;
+declare const brain_isCoherent: typeof isCoherent;
+declare const brain_kuramotoStep: typeof kuramotoStep;
+declare const brain_orderParameter: typeof orderParameter;
+declare const brain_phaseLockingValue: typeof phaseLockingValue;
+declare const brain_wrapTo2Pi: typeof wrapTo2Pi;
+declare const brain_wrapToPi: typeof wrapToPi;
+declare namespace brain {
+  export { type brain_CoherenceConfig as CoherenceConfig, type brain_CoherenceInput as CoherenceInput, type brain_CoherenceMetrics as CoherenceMetrics, type brain_CoherenceResult as CoherenceResult, type brain_KuramotoStepOptions as KuramotoStepOptions, type brain_OrderParameter as OrderParameter, brain_calculateCoherence as calculateCoherence, brain_calculateCoherenceWithExplanations as calculateCoherenceWithExplanations, brain_getCoherenceSuggestions as getCoherenceSuggestions, brain_isCoherent as isCoherent, brain_kuramotoStep as kuramotoStep, brain_orderParameter as orderParameter, brain_phaseLockingValue as phaseLockingValue, brain_wrapTo2Pi as wrapTo2Pi, brain_wrapToPi as wrapToPi };
 }
+
 /**
- * Folded (serializable) representation of a Sematon.
- * Suitable for JSON serialization, mesh relay, or persistence.
+ * Agent Communication Bus — in-memory message passing for skill agents.
+ *
+ * Scoped per skill run. Agents publish findings, review requests, and
+ * delegation requests. Downstream agents receive accumulated context
+ * via their system prompt.
+ *
+ * @module skills/agent-bus
  */
-interface FoldedSematon {
-    id: string;
-    kind: SematonKind;
+type AgentMessageType = "finding" | "question" | "review_request" | "review_response" | "delegation_request" | "delegation_response";
+interface AgentMessage {
+    fromAgent: string;
+    toAgent?: string;
+    type: AgentMessageType;
     payload: string;
-    witness: SematonWitness;
-    padicAddress: string;
-    entropy: number;
-    density: number;
-    impedance: number;
-    shapeHash: string;
-    constructive: boolean;
-    createdAt: number;
-    source: string;
+    timestamp: number;
+    runId: string;
 }
-interface SematonConfig<T> {
-    kind: SematonKind;
-    payload: T;
-    witness: SematonWitness;
-    padicAddress?: string;
-    source?: string;
+type MessageHandler = (msg: AgentMessage) => void;
+interface AgentBus {
+    publish(msg: AgentMessage): void;
+    query(filter: {
+        fromAgent?: string;
+        type?: string;
+    }): AgentMessage[];
+    subscribe(agentId: string, handler: MessageHandler): () => void;
+    getAll(): AgentMessage[];
 }
 /**
- * Create a new Sematon from configuration.
- */
-declare function createSematon<T>(config: SematonConfig<T>): Sematon<T>;
-/**
- * Get the Shannon entropy of a sematon's payload.
+ * Create an AgentBus scoped to a single skill run.
+ * Messages are stored in-memory (array). No persistence needed —
+ * the bus lifetime matches the SkillRunner instance.
  */
-declare function sematonEntropy<T>(sematon: Sematon<T>): number;
+declare function createAgentBus(runId: string): AgentBus;
+
 /**
- * Get the semantic density of a sematon.
+ * Protocol SDK — MCP and A2A protocol connections
+ *
+ * Delegation primitives and agent communication types.
+ * Hides MCP client lifecycle, A2A internals.
+ *
+ * @copyright © 2026 Intuition Labs LLC. All rights reserved. Patent Pending.
+ * @module sdk/protocol
  */
-declare function sematonDensity<T>(sematon: Sematon<T>): number;
+
+type protocol_AgentBus = AgentBus;
+type protocol_AgentMessage = AgentMessage;
+type protocol_AgentMessageType = AgentMessageType;
+type protocol_DelegationChain = DelegationChain;
+type protocol_DelegationEdge<S = SurfaceId, T = SurfaceId> = DelegationEdge<S, T>;
+type protocol_DelegationEdgeInput<S = SurfaceId, T = SurfaceId> = DelegationEdgeInput<S, T>;
+type protocol_DelegationEndpoint<S = SurfaceId> = DelegationEndpoint<S>;
+declare const protocol_createAgentBus: typeof createAgentBus;
+declare const protocol_createDelegationChain: typeof createDelegationChain;
+declare const protocol_createDelegationEdge: typeof createDelegationEdge;
+declare const protocol_isValidSurfaceId: typeof isValidSurfaceId;
+declare namespace protocol {
+  export { type protocol_AgentBus as AgentBus, type protocol_AgentMessage as AgentMessage, type protocol_AgentMessageType as AgentMessageType, type protocol_DelegationChain as DelegationChain, type protocol_DelegationEdge as DelegationEdge, type protocol_DelegationEdgeInput as DelegationEdgeInput, type protocol_DelegationEndpoint as DelegationEndpoint, protocol_createAgentBus as createAgentBus, protocol_createDelegationChain as createDelegationChain, protocol_createDelegationEdge as createDelegationEdge, protocol_isValidSurfaceId as isValidSurfaceId };
+}
+
 /**
- * Check if a sematon can participate in further transformations.
- * This is the Deutsch-Marletto constructor invariant.
+ * Trigger Type System
+ *
+ * Canonical discriminated-union types for all stack trigger mechanisms.
+ * A trigger defines *when* and *how* a stack run is initiated.
+ *
+ * Usage:
+ *   - StackManifestV0.triggerConfig holds the declared trigger for a stack.
+ *   - TriggerContext is injected into every run so downstream nodes can inspect
+ *     how the execution was started.
+ *   - NodeSecretRef lets webhook triggers reference vault-backed HMAC keys
+ *     through the provider control plane instead of inline secrets.
+ *
+ * @module machines/core/types/trigger
  */
-declare function isRealizable<T>(sematon: Sematon<T>): boolean;
+
+/** Run the stack on a fixed time interval. */
+interface IntervalTriggerConfig {
+    kind: "interval";
+    /** Seconds between runs. Minimum enforced at 1. */
+    everySeconds: number;
+}
 /**
- * Compute distance between two sematons using payload cosine similarity
- * weighted by witness R proximity.
+ * Run the stack on a standard 5-field cron schedule.
  *
- * Distance in [0, 1] where 0 = identical, 1 = maximally different.
+ * The expression follows the POSIX/Vixie-cron syntax:
+ *   `minute hour day-of-month month day-of-week`
+ *
+ * @example "0 9 * * 1-5"   // weekdays at 09:00 UTC
+ * @example "* /15 * * * *" // every 15 minutes (non-standard extended form)
  */
-declare function sematonDistance<T>(a: Sematon<T>, b: Sematon<T>): number;
+interface CronTriggerConfig {
+    kind: "cron";
+    /** Standard 5-field cron expression. */
+    expression: string;
+    /** IANA timezone name (default: "UTC"). */
+    timezone?: string;
+}
 /**
- * Fold a Sematon into a JSON-serializable representation.
- * HVM γ (construct) — compress for handoff, persistence, or relay.
+ * Run the stack when an inbound HTTP webhook is received.
+ *
+ * Secret verification:
+ *   - Use `secretRef` for production — the key stays server-side.
+ *   - Use the inline `secret` field only for dev/test environments.
  */
-declare function foldSematon<T>(sematon: Sematon<T>): FoldedSematon;
+interface WebhookTriggerConfig {
+    kind: "webhook";
+    /** Relative path segment appended to the stack webhook base URL. */
+    path?: string;
+    /** Accepted HTTP method (default: "POST"). */
+    method?: "GET" | "POST" | "PUT" | "PATCH";
+    /**
+     * Inline HMAC signing secret.
+     * Production deployments should prefer `secretRef` to keep the value
+     * server-side in the Supabase vault.
+     */
+    secret?: string;
+    /** Vault-backed secret reference for the HMAC signing key. */
+    secretRef?: NodeSecretRef;
+}
 /**
- * Unfold a serialized representation back into a Sematon.
- * HVM δ (duplicate) — expand from handoff, persistence, or relay.
+ * Run the stack when a matching AXON event is published on the given topic.
+ *
+ * AXON cross-layer events are published via `system.signal.emit.v1` nodes or
+ * directly through the AXON kernel. The filter is applied against the event
+ * payload before dispatching.
  */
-declare function unfoldSematon<T>(folded: FoldedSematon): Sematon<T>;
+interface EventTriggerConfig {
+    kind: "event";
+    /** AXON event topic string (e.g. "brain.index.complete", "user.action.*"). */
+    topic: string;
+    /**
+     * Optional shallow equality filter applied to the event payload.
+     * Only events whose payload contains all key-value pairs in this map
+     * will dispatch the stack run.
+     */
+    filter?: Record<string, unknown>;
+}
+/** Run the stack only when explicitly requested via the API or UI. */
+interface ManualTriggerConfig {
+    kind: "manual";
+}
+/** Discriminated union over all trigger kinds. */
+type TriggerConfig = IntervalTriggerConfig | CronTriggerConfig | WebhookTriggerConfig | EventTriggerConfig | ManualTriggerConfig;
 
 /**
- * L0 Realizability Trace — Constructor Proof Runtime
+ * Runtime tier for node execution.
  *
- * A RealizabilityTrace is an ordered sequence of RealizabilitySteps.
- * Each step records: input Sematon(s), output Sematon(s), a ConvergenceWitness
- * snapshot, and information gain.
+ * Defines the execution environment for computational nodes:
+ * - `worker`: Web Worker/service worker
+ * - `container-lite`: Lightweight containerized runtime
+ * - `webcontainer`: Browser-based container (WebAssembly)
+ * - `edge`: Edge function/serverless
+ * - `wasm-hvm`: WebAssembly with HVM (Higher-order Virtual Machine)
+ * - `stack`: Nested stack execution
  *
- * verifyTrace() checks three constructor invariants:
- *   1. Each input was realizable (constructive flag true)
- *   2. Each witness converged (R above threshold)
- *   3. Information is non-decreasing across steps
+ * @example
+ * const tier: RuntimeTier = "worker";
+ */
+type RuntimeTier = "worker" | "container-lite" | "webcontainer" | "edge" | "wasm-hvm" | "stack";
+/**
+ * Secret reference for node execution.
  *
- * This is the Deutsch-Marletto constructor invariant made executable:
- * after transforming inputs, the system retains the ability to transform again.
+ * Links a secret from the vault into node environment.
  *
- * @license BUSL-1.1
- * @copyright © 2026 Intuition Labs LLC. All rights reserved. Patent Pending.
- * @module core/L0/realizability
+ * @example
+ * const secret: NodeSecretRef = {
+ *   name: "api_key",
+ *   scope: "stack",
+ *   env: "OPENAI_API_KEY",
+ *   required: true
+ * };
  */
-
-interface RealizabilityStep {
-    /** Step index in the trace */
-    index: number;
-    /** Input sematons consumed by this step */
-    inputs: Sematon[];
-    /** Output sematons produced by this step */
-    outputs: Sematon[];
-    /** Convergence witness at this step */
-    witness: SematonWitness;
-    /** Total information content of outputs (bits) */
-    informationGain: number;
-    /** Timestamp */
-    timestamp: number;
+interface NodeSecretRef {
+    /** Secret identifier in vault */
+    name: string;
+    /** Resolution scope: node-local or stack-wide */
+    scope: "node" | "stack";
+    /** Environment variable name (defaults to name if omitted) */
+    env?: string;
+    /** Whether secret must exist (default: false) */
+    required?: boolean;
 }
-interface RealizabilityTrace {
-    /** Unique trace identifier */
+/**
+ * Base manifest fields shared by nodes and stacks.
+ *
+ * @internal
+ */
+interface BaseManifestV0 {
+    /** Unique identifier (must be stable across versions) */
     id: string;
-    /** Ordered sequence of steps */
-    steps: RealizabilityStep[];
-    /** Whether the trace has been verified */
-    verified: boolean;
-    /** Total information gain across all steps */
-    totalInfoGain: number;
-    /** Count of constructive (realizable) steps */
-    constructiveSteps: number;
-    /** Creation timestamp */
-    createdAt: number;
+    /** Semantic version (e.g., "1.0.0") */
+    version: string;
+    /** Human-readable name */
+    name?: string;
+    /** Description of functionality */
+    description?: string;
+    /** Security and resource policies */
+    policies?: NodePolicy | StackPolicies;
+    /** Arbitrary metadata for extensions */
+    metadata?: Record<string, unknown>;
 }
-interface VerificationSuccess {
-    valid: true;
-    totalInfoGain: number;
-    constructiveSteps: number;
+/**
+ * Stack-level secret scope definition.
+ *
+ * Defines which nodes can access a secret.
+ *
+ * @example
+ * const secretScope: StackSecretScope = {
+ *   scope: ["fetch-node", "transform-node"],
+ *   required: true
+ * };
+ */
+interface StackSecretScope {
+    /** Node IDs that can access this secret */
+    scope: string[];
+    /** Whether secret must exist */
+    required?: boolean;
 }
-interface VerificationFailure {
-    valid: false;
-    failureStep: number;
-    reason: string;
+/**
+ * Stack-level runtime tier configuration.
+ *
+ * Allows stack-wide defaults with per-node overrides.
+ *
+ * @example
+ * const runtimes: StackRuntimes = {
+ *   default: ["worker", "edge"],
+ *   overrides: {
+ *     "heavy-compute": ["container-lite"]
+ *   }
+ * };
+ */
+interface StackRuntimes {
+    /** Default runtime tiers for all nodes */
+    default?: RuntimeTier[];
+    /** Per-node runtime tier overrides (nodeId -> tiers) */
+    overrides?: Record<string, RuntimeTier[]>;
 }
-type VerificationResult = VerificationSuccess | VerificationFailure;
 /**
- * Create a single realizability step.
- * Computes informationGain as the sum of output sematon entropies.
+ * Reference from a stack node to a brain connector instance.
+ *
+ * Binds the connector's extracted data chunks into this node's input,
+ * allowing RAG / knowledge-graph results to flow into the execution graph.
  */
-declare function createRealizabilityStep(index: number, inputs: Sematon[], outputs: Sematon[], witness: SematonWitness): RealizabilityStep;
+interface ConnectorRef {
+    /** ID of the ConnectorInstance in the brain pipeline. */
+    connectorId: string;
+    /** ID of the ConnectorDefinition (catalog entry). */
+    definitionId: string;
+    /**
+     * Optional shallow filter applied to DataChunks from this connector.
+     * Only chunks whose metadata contains all key-value pairs in this map
+     * will be included.
+     */
+    dataChunkFilter?: Record<string, unknown>;
+}
 /**
- * Construct a RealizabilityTrace from an ordered sequence of steps.
- * Computes totalInfoGain and constructiveSteps.
+ * Node configuration within a stack.
+ *
+ * References a node manifest and provides instance-specific config.
+ *
+ * @example
+ * const nodeConfig: StackNodeConfig = {
+ *   id: "fetch-1",
+ *   nodeRef: "http-fetch",
+ *   config: { timeout: 5000 },
+ *   runtimes: ["edge"],
+ *   secrets: ["api_key"]
+ * };
  */
-declare function traceRealizability(steps: RealizabilityStep[]): RealizabilityTrace;
+interface StackNodeConfig {
+    /** Unique ID within stack */
+    id: string;
+    /** Reference to NodeManifestV0.id */
+    nodeRef: string;
+    /** Node-specific configuration */
+    config?: Record<string, unknown>;
+    /** Runtime tier override */
+    runtimes?: RuntimeTier[];
+    /** Security policy override */
+    policies?: NodePolicy;
+    /** Secret names from stack.secrets */
+    secrets?: string[];
+    /**
+     * Reference to a brain connector whose data chunks feed this node.
+     * The orchestrator resolves this at run-time before invoking the node.
+     */
+    connectorRef?: ConnectorRef;
+}
 /**
- * Verify a realizability trace against three constructor invariants:
- *   1. Each step's inputs must all be realizable
- *   2. Each step's witness must have converged
- *   3. Information is non-decreasing across steps
+ * Directed edge connecting two nodes in the stack DAG.
  *
- * Returns VerificationSuccess or VerificationFailure with step index and reason.
+ * Defines data flow from one node's outputs to another's inputs.
+ *
+ * @example
+ * const edge: StackEdge = {
+ *   from: "fetch-1",
+ *   to: "transform-1",
+ *   map: { "data": "input" }
+ * };
  */
-declare function verifyTrace(trace: RealizabilityTrace): VerificationResult;
+interface StackEdge {
+    /** Source node ID */
+    from: string;
+    /** Target node ID */
+    to: string;
+    /** Output-to-input key mapping (defaults to identity) */
+    map?: Record<string, string>;
+}
 /**
- * Fold a RealizabilityTrace into a JSON string.
- * Sematons are folded via foldSematon first for portable serialization.
+ * Manifest layer provenance.
+ *
+ * - `L0`: Landing/Zero layer (low-level primitives)
+ * - `L1`: Compose/Platform layer (higher-level abstractions)
  */
-declare function foldTrace(trace: RealizabilityTrace): string;
+type ManifestLayer = "L0" | "L1" | "L2" | "L3" | "L4" | "L5";
 /**
- * Unfold a JSON string back into a RealizabilityTrace.
- * Sematons are unfolded via unfoldSematon.
+ * Stack manifest for DAG orchestrator.
+ *
+ * Defines a complete workflow as a directed acyclic graph (DAG) of nodes.
+ *
+ * @example
+ * const stack: StackManifestV0 = {
+ *   id: "data-pipeline",
+ *   version: "1.0.0",
+ *   nodes: [
+ *     { id: "fetch", nodeRef: "http-fetch", config: { url: "..." } },
+ *     { id: "transform", nodeRef: "llm-transform" }
+ *   ],
+ *   edges: [
+ *     { from: "fetch", to: "transform", map: { data: "input" } }
+ *   ],
+ *   secrets: {
+ *     api_key: { scope: ["fetch"], required: true }
+ *   }
+ * };
  */
-declare function unfoldTrace(json: string): RealizabilityTrace;
+interface StackManifestV0 extends BaseManifestV0 {
+    /** Node instances in this stack */
+    nodes: StackNodeConfig[];
+    /** Edges connecting nodes (data flow) */
+    edges?: StackEdge[];
+    /** Stack-level secret definitions */
+    secrets?: Record<string, StackSecretScope>;
+    /** Runtime tier configuration */
+    runtimes?: StackRuntimes;
+    /** Provenance layer (L0 or L1) */
+    layer?: ManifestLayer;
+    /**
+     * Declared trigger for this stack.
+     *
+     * Defines when and how the stack is automatically started.
+     * The orchestrator and scheduler use this at registration time.
+     * When absent, the stack is manual-only.
+     */
+    triggerConfig?: TriggerConfig;
+}
 
 /**
- * L0 Foundation Layer
+ * Skill Manifest Types (L1)
  *
- * Provides categorical foundations and information-theoretic primitives
- * for cross-layer mappings in the AXON architecture.
+ * Core types for the Skills Platform. A SkillManifest extends StackManifestV0
+ * with skill-specific metadata — a skill IS a stack with agent orchestration.
  *
- * @module core/L0
+ * @module skills/types
  */
 
-type index_AsyncIso<A, B> = AsyncIso<A, B>;
-type index_AsyncMorphism<A, B> = AsyncMorphism<A, B>;
-type index_Category<Obj, Hom> = Category<Obj, Hom>;
-type index_Coproduct<A, B> = Coproduct<A, B>;
-type index_DerivationOptions = DerivationOptions;
-type index_DerivedIso<A, B> = DerivedIso<A, B>;
-type index_Embed<A, B> = Embed<A, B>;
-type index_FieldMapping = FieldMapping;
-type index_FoldedSematon = FoldedSematon;
-type index_Functor<F> = Functor<F>;
-type index_InformationPreservation = InformationPreservation;
-type index_Iso<A, B> = Iso<A, B>;
-type index_IsoMeta = IsoMeta;
-declare const index_LAYERS: typeof LAYERS;
-type index_LayerBridge<From extends LayerId, To extends LayerId, A, B> = LayerBridge<From, To, A, B>;
-type index_LayerId = LayerId;
-type index_LayerMeta = LayerMeta;
-type index_Morphism<A, B> = Morphism<A, B>;
-type index_NaturalTransformation<F, G> = NaturalTransformation<F, G>;
-type index_Product<A, B> = Product<A, B>;
-type index_Proof<P> = Proof<P>;
-type index_RealizabilityStep = RealizabilityStep;
-type index_RealizabilityTrace = RealizabilityTrace;
-type index_SemanticDensity = SemanticDensity;
-type index_Sematon<T = unknown> = Sematon<T>;
-type index_SematonConfig<T> = SematonConfig<T>;
-type index_SematonKind = SematonKind;
-type index_SematonWitness = SematonWitness;
-type index_TypeShape = TypeShape;
-declare const index_VALID_TRANSITIONS: typeof VALID_TRANSITIONS;
-type index_VerificationFailure = VerificationFailure;
-type index_VerificationResult = VerificationResult;
-type index_VerificationSuccess = VerificationSuccess;
-type index_Verified<T, P> = Verified<T, P>;
-declare const index_calculateSemanticDensity: typeof calculateSemanticDensity;
-declare const index_canEmbed: typeof canEmbed;
-declare const index_checkCompatibility: typeof checkCompatibility;
-declare const index_compose: typeof compose;
-declare const index_composeAsync: typeof composeAsync;
-declare const index_composeIso: typeof composeIso;
-declare const index_conditionalEntropy: typeof conditionalEntropy;
-declare const index_cosineSimilarity: typeof cosineSimilarity;
-declare const index_createBridge: typeof createBridge;
-declare const index_createRealizabilityStep: typeof createRealizabilityStep;
-declare const index_createSematon: typeof createSematon;
-declare const index_deriveFieldMappings: typeof deriveFieldMappings;
-declare const index_deriveIsomorphism: typeof deriveIsomorphism;
-declare const index_entropy: typeof entropy;
-declare const index_estimateComplexity: typeof estimateComplexity;
-declare const index_extractShape: typeof extractShape;
-declare const index_fold: typeof fold;
-declare const index_foldSematon: typeof foldSematon;
-declare const index_foldTrace: typeof foldTrace;
-declare const index_identity: typeof identity;
-declare const index_identityIso: typeof identityIso;
-declare const index_invertIso: typeof invertIso;
-declare const index_isRealizable: typeof isRealizable;
-declare const index_isValidTransition: typeof isValidTransition;
-declare const index_jointEntropy: typeof jointEntropy;
-declare const index_jsDivergence: typeof jsDivergence;
-declare const index_klDivergence: typeof klDivergence;
-declare const index_left: typeof left;
-declare const index_measurePreservation: typeof measurePreservation;
-declare const index_mutualInformation: typeof mutualInformation;
-declare const index_normalize: typeof normalize;
-declare const index_right: typeof right;
-declare const index_sematonDensity: typeof sematonDensity;
-declare const index_sematonDistance: typeof sematonDistance;
-declare const index_sematonEntropy: typeof sematonEntropy;
-declare const index_shapeSimilarity: typeof shapeSimilarity;
-declare const index_traceRealizability: typeof traceRealizability;
-declare const index_unfoldSematon: typeof unfoldSematon;
-declare const index_unfoldTrace: typeof unfoldTrace;
-declare const index_verifyIsomorphism: typeof verifyIsomorphism;
-declare const index_verifyTrace: typeof verifyTrace;
-declare namespace index {
-  export { type index_AsyncIso as AsyncIso, type index_AsyncMorphism as AsyncMorphism, type index_Category as Category, type index_Coproduct as Coproduct, type index_DerivationOptions as DerivationOptions, type index_DerivedIso as DerivedIso, type index_Embed as Embed, type index_FieldMapping as FieldMapping, type index_FoldedSematon as FoldedSematon, type index_Functor as Functor, type index_InformationPreservation as InformationPreservation, type index_Iso as Iso, type index_IsoMeta as IsoMeta, index_LAYERS as LAYERS, type index_LayerBridge as LayerBridge, type index_LayerId as LayerId, type index_LayerMeta as LayerMeta, type index_Morphism as Morphism, type index_NaturalTransformation as NaturalTransformation, type index_Product as Product, type index_Proof as Proof, type index_RealizabilityStep as RealizabilityStep, type index_RealizabilityTrace as RealizabilityTrace, type index_SemanticDensity as SemanticDensity, type index_Sematon as Sematon, type index_SematonConfig as SematonConfig, type index_SematonKind as SematonKind, type index_SematonWitness as SematonWitness, type index_TypeShape as TypeShape, index_VALID_TRANSITIONS as VALID_TRANSITIONS, type index_VerificationFailure as VerificationFailure, type index_VerificationResult as VerificationResult, type index_VerificationSuccess as VerificationSuccess, type index_Verified as Verified, index_calculateSemanticDensity as calculateSemanticDensity, index_canEmbed as canEmbed, index_checkCompatibility as checkCompatibility, index_compose as compose, index_composeAsync as composeAsync, index_composeIso as composeIso, index_conditionalEntropy as conditionalEntropy, index_cosineSimilarity as cosineSimilarity, index_createBridge as createBridge, index_createRealizabilityStep as createRealizabilityStep, index_createSematon as createSematon, index_deriveFieldMappings as deriveFieldMappings, index_deriveIsomorphism as deriveIsomorphism, index_entropy as entropy, index_estimateComplexity as estimateComplexity, index_extractShape as extractShape, index_fold as fold, index_foldSematon as foldSematon, index_foldTrace as foldTrace, index_identity as identity, index_identityIso as identityIso, index_invertIso as invertIso, index_isRealizable as isRealizable, index_isValidTransition as isValidTransition, index_jointEntropy as jointEntropy, index_jsDivergence as jsDivergence, index_klDivergence as klDivergence, index_left as left, index_measurePreservation as measurePreservation, index_mutualInformation as mutualInformation, index_normalize as normalize, index_right as right, index_sematonDensity as sematonDensity, index_sematonDistance as sematonDistance, index_sematonEntropy as sematonEntropy, index_shapeSimilarity as shapeSimilarity, index_traceRealizability as traceRealizability, index_unfoldSematon as unfoldSematon, index_unfoldTrace as unfoldTrace, index_verifyIsomorphism as verifyIsomorphism, index_verifyTrace as verifyTrace };
+type SkillCategory = "startup" | "legal" | "finance" | "engineering" | "content" | "research" | "operations" | "marketing" | "verification";
+type SkillOutputType = "document" | "website" | "spreadsheet" | "presentation" | "codebase" | "analysis" | "dataset" | "visual" | "video" | "audio" | "composite";
+declare const SKILL_CATEGORIES: readonly SkillCategory[];
+declare const SKILL_TIERS: readonly ["flagship", "professional", "utility"];
+type SkillTier = (typeof SKILL_TIERS)[number];
+declare const SKILL_RANKS: readonly ["skill", "flow", "fleet", "org", "society"];
+type SkillRank = (typeof SKILL_RANKS)[number];
+/** Effective-dated rank assignment — immutable audit trail */
+interface RankAssignment {
+    /** Current rank */
+    rank: SkillRank;
+    /** ISO 8601 timestamp when this rank became effective */
+    effectiveFrom: string;
+    /** ISO 8601 timestamp when this rank was superseded (null = current) */
+    effectiveTo: string | null;
+    /** Evidence that promotion invariants were satisfied */
+    proof?: PromotionProof;
 }
-
 /**
- * Action Algebra — Input-Agnostic Action Types
- *
- * All input surfaces (keyboard, gamepad, voice, touch) compile down to this algebra.
- * All executors interpret this algebra into effects.
- *
- * @module core/primitives/action
+ * Promotion proof — the Curry-Howard witness type.
+ * Each promotion requires structural evidence that the entity
+ * satisfies the invariants of the target rank.
  */
-
-type NavigationTarget = {
-    kind: "surface";
-    surface: SurfaceId;
-} | {
-    kind: "tab";
-    tab: string;
-} | {
-    kind: "route";
-    path: string;
-    params?: Record<string, string>;
-} | {
-    kind: "focus";
-    elementId: string;
-} | {
-    kind: "relative";
-    direction: "up" | "down" | "left" | "right";
-};
-type SkillRef = {
-    kind: "slug";
-    slug: string;
-} | {
-    kind: "id";
-    id: string;
-} | {
-    kind: "command";
-    commandId: string;
-};
-interface ComposeEdge {
-    sourceId: string;
-    targetId: string;
-    port?: string;
-}
-type ObserveTarget = {
-    kind: "metric";
-    metricId: string;
-} | {
-    kind: "panel";
-    panelId: string;
-} | {
-    kind: "surface";
-    surface: SurfaceId;
-};
-interface DelegateAssignment {
-    agentId: string;
-    taskDescription: string;
-    context?: Record<string, unknown>;
-}
-type Action = {
-    verb: "navigate";
-    target: NavigationTarget;
-} | {
-    verb: "execute";
-    skill: SkillRef;
-    args?: Record<string, unknown>;
-} | {
-    verb: "compose";
-    edge: ComposeEdge;
-} | {
-    verb: "observe";
-    target: ObserveTarget;
-    zoom?: number;
-} | {
-    verb: "delegate";
-    assignment: DelegateAssignment;
-} | {
-    verb: "palette";
-    query?: string;
-} | {
-    verb: "cancel";
-} | {
-    verb: "undo";
-} | {
-    verb: "redo";
-} | {
-    verb: "sequence";
-    actions: Action[];
-};
-type InputSurface = "keyboard" | "gamepad" | "voice" | "touch" | "command_palette";
-interface ActionEvent {
-    action: Action;
-    source: InputSurface;
-    timestamp: number;
-    inputTrace?: string[];
+interface PromotionProof {
+    /** Source rank */
+    from: SkillRank;
+    /** Target rank */
+    to: SkillRank;
+    /** Structural invariant checks that passed */
+    invariants: PromotionInvariant[];
+    /** Timestamp of promotion evaluation */
+    evaluatedAt: string;
+    /** Quality score at time of promotion (0-1) */
+    qualityScore: number;
 }
-interface ActionContext {
-    activeSurface: SurfaceId;
-    activeTab: string;
-    selection: string[];
-    isTextFocused: boolean;
-    isModalOpen: boolean;
+interface PromotionInvariant {
+    /** Invariant name (e.g., "has_convergence", "has_3_plus_skills", "has_mesh_events") */
+    name: string;
+    /** Whether this invariant was satisfied */
+    satisfied: boolean;
+    /** Human-readable evidence */
+    evidence?: string;
 }
-type ActionPredicate = (ctx: ActionContext) => boolean;
-interface KeyboardTrigger {
-    type: "chord" | "key" | "sequence";
-    keys: string[];
-    timeout?: number;
+interface SkillCapabilities {
+    /** Allow image generation via connected media providers */
+    allowImageGen?: boolean;
+    /** Allow video generation via connected media providers */
+    allowVideoGen?: boolean;
+    /** Allow MCP tool access during execution */
+    allowTools?: boolean;
+    /** Allow web search during execution */
+    allowWebSearch?: boolean;
+    /** Allow code execution in sandbox */
+    allowCodeExec?: boolean;
 }
-type GamepadButton = "a" | "b" | "x" | "y" | "lb" | "rb" | "lt" | "rt" | "back" | "start" | "ls" | "rs" | "dpad_up" | "dpad_down" | "dpad_left" | "dpad_right";
-interface GamepadTrigger {
-    type: "button" | "combo" | "axis";
-    buttons?: GamepadButton[];
-    sequence?: {
-        button: GamepadButton;
-        holdMs?: number;
-    }[];
-    axis?: {
-        stick: "left" | "right";
-        direction: "up" | "down" | "left" | "right";
-        threshold?: number;
-    };
+interface SkillHealth {
+    /** Overall health score 0-100 */
+    score: number;
+    /** Health grade derived from score */
+    grade: "A" | "B" | "C" | "D" | "F";
+    /** Last N run outcomes for sparkline display */
+    recentRuns: SkillRunSummary[];
+    /** Average convergence iterations across recent runs */
+    avgConvergenceIterations: number;
+    /** Average quality score across recent runs (0-1) */
+    avgQualityScore: number;
+    /** Success rate as percentage (0-100) */
+    successRate: number;
+    /** Last run timestamp */
+    lastRunAt: string | null;
+    /** Total run count */
+    totalRuns: number;
+}
+interface SkillRunSummary {
+    /** Run ID */
+    runId: string;
+    /** Run status */
+    status: "completed" | "failed" | "cancelled";
+    /** Quality score (0-1) */
+    qualityScore: number;
+    /** Duration in seconds */
+    duration: number;
+    /** Timestamp */
+    timestamp: string;
 }
-interface VoiceTrigger {
-    type: "intent";
-    patterns: string[];
-    confidenceThreshold?: number;
+interface SkillAgent {
+    /** Agent role name (e.g., "Market Researcher", "Legal Analyst") */
+    role: string;
+    /** What this agent does in the workflow */
+    description: string;
+    /** Maps to a NodeManifestV0.id in the stack */
+    nodeRef?: string;
+    /** When true, a synthetic peer reviewer evaluates this agent's output after completion */
+    peerReview?: boolean;
 }
-interface TouchTrigger {
-    type: "gesture";
-    gesture: "swipe_left" | "swipe_right" | "swipe_up" | "swipe_down" | "pinch_in" | "pinch_out" | "long_press" | "double_tap" | "three_finger_swipe";
+interface SkillSampleOutput {
+    type: SkillOutputType;
+    title: string;
+    /** Screenshot or live preview URL */
+    previewUrl?: string;
+    description: string;
 }
-type InputTrigger = KeyboardTrigger | GamepadTrigger | VoiceTrigger | TouchTrigger;
-interface ActionBinding {
-    id: string;
-    action: Action;
+/** External service dependency for a skill */
+interface SkillServiceRequirement {
+    /** Unique key for this requirement (e.g., "search", "database", "email") */
+    key: string;
+    /** Human-readable label */
     label: string;
-    category: string;
-    when: ActionPredicate;
-    trigger: InputTrigger;
-    surface: InputSurface;
+    /** Type of service needed */
+    type: "mcp" | "api" | "credential";
+    /** Description of what this service is used for */
+    description: string;
+    /** Whether this service is required or optional */
+    required: boolean;
+    /** Suggested MCP server names (for type: "mcp") */
+    suggestedServers?: string[];
+}
+interface SkillMeta<TInput extends Record<string, unknown> = Record<string, unknown>> {
+    /** Unique skill slug (url-safe) */
+    slug: string;
+    /** Display name */
+    title: string;
+    /** One-line value proposition */
+    tagline: string;
+    /** Detailed description (markdown) */
+    description: string;
+    /** Skill category */
+    category: SkillCategory;
+    /** Skill tier (complexity/impact level) */
+    tier: SkillTier;
+    /** Expected output artifact types */
+    outputs: SkillOutputType[];
+    /** Estimated execution time range in seconds [min, max] */
+    estimatedTime: [number, number];
+    /** Required input schema (JSON Schema) */
+    inputSchema: JSONSchema7;
+    /** Agent roles involved in this skill */
+    agents: SkillAgent[];
+    /** Sample input for demo/preview (typed to match inputSchema) */
+    sampleInput?: TInput;
+    /** Sample output artifacts for showcase */
+    sampleOutputs?: SkillSampleOutput[];
+    /** Tags for filtering */
+    tags: string[];
+    /** Author */
+    author: string;
+    /** Icon identifier (from icon set) */
+    icon?: string;
+    /** Cosmic gradient pair index (0-7 from cosmicGradients) */
+    gradientIndex?: number;
+    /** Output schema for composition chaining (JSON Schema) */
+    outputSchema?: JSONSchema7;
+    /** Allow agents to dynamically delegate tasks to ephemeral agents. Max 2 per run. */
+    allowDelegation?: boolean;
+    /** External service dependencies (MCP servers, APIs, credentials) */
+    services?: SkillServiceRequirement[];
+    /** Runtime capability toggles (image gen, video gen, tools, etc.) */
+    capabilities?: SkillCapabilities;
+    /** Current rank in the hierarchy (default: "skill") */
+    rank?: SkillRank;
+    /** Effective-dated rank history — immutable audit trail */
+    rankHistory?: RankAssignment[];
+    /**
+     * Convergence configuration for iterative agent output refinement.
+     *
+     * Future optimization: the manual convergence loop in runner.ts could be
+     * replaced by `withRetry()` + `withCircuitBreaker()` from
+     * `lib/terminals-tech/core/primitives/middleware` — they provide the same
+     * retry/backoff/threshold semantics with composable middleware chaining.
+     * See also `createRefinementLoop()` from `primitives/refinement` which
+     * encapsulates the score/delta/plateau logic as a standalone primitive.
+     */
+    convergence?: {
+        /** Max refinement iterations per agent. Default 1 (no refinement), max 5. */
+        maxIterations: number;
+        /** Quality threshold (0-1). Agent output must meet this to pass. Default 0.7. */
+        qualityThreshold: number;
+        /** Minimum quality improvement per iteration. Stops early if delta < this. Default 0.05. */
+        minDelta: number;
+        /** Refinement strategy: retry (re-execute), critique (LLM critic), refine (critique + inject feedback). */
+        strategy: "retry" | "critique" | "refine";
+    };
 }
-/** Sequence two actions (flattens nested sequences) */
-declare function seq(a: Action, b: Action): Action;
-/** Navigate then execute */
-declare function goAndRun(target: NavigationTarget, skill: SkillRef): Action;
-/** Delegate then observe */
-declare function delegateAndWatch(assignment: DelegateAssignment, metric: ObserveTarget): Action;
-
 /**
- * ActionBus — Singleton event bus for the Action Algebra
+ * A SkillManifest extends StackManifestV0 with skill-specific metadata.
  *
- * All input surfaces publish ActionEvents here.
- * The executor and any observers subscribe here.
+ * This is the core type — a skill IS a stack manifest with agent orchestration
+ * metadata. The `skill` field contains all presentation and execution metadata.
  *
- * @module core/primitives/action-bus
+ * The `TInput` parameter establishes compile-time correspondence between
+ * the JSON Schema `inputSchema`, the typed `sampleInput`, and the runtime
+ * input validated by `SkillRunner.start()`.
  */
-
-type ActionBusEvents = {
-    "action:dispatched": ActionEvent;
-    "action:executed": ActionEvent & {
-        result: "success" | "error";
-        error?: string;
-    };
-    "action:cancelled": {
-        reason: string;
-        timestamp: number;
-    };
-    "context:changed": ActionContext;
+interface SkillManifest<TInput extends Record<string, unknown> = Record<string, unknown>> extends StackManifestV0 {
+    /** Skill-specific metadata */
+    skill: SkillMeta<TInput>;
+}
+declare const SKILL_RUN_STATUSES: readonly ["pending", "running", "gate_pending", "paused", "resuming", "retrying", "completed", "failed", "cancelled"];
+type SkillRunStatus = (typeof SKILL_RUN_STATUSES)[number];
+
+/**
+ * Skill Registry + Catalog Bridge
+ *
+ * Follows the applet-node-adapter.ts pattern — registers skills into the
+ * node catalog via registerManifestProvider for "skill:*" resolution.
+ *
+ * @module skills/registry
+ */
+
+declare function registerSkill(skill: SkillManifest): void;
+declare function getSkill(slug: string): SkillManifest | undefined;
+declare function getAllSkills(): SkillManifest[];
+declare function getSkillsByCategory(category: SkillCategory): SkillManifest[];
+declare function getSkillCount(): number;
+/**
+ * Ensures flagship skills are registered. Safe to call from API routes
+ * (SSR context) where the client-side side-effect import hasn't run.
+ * Idempotent — skips if registry is already populated.
+ */
+declare function ensureSkillsRegistered(): Promise<void>;
+
+/**
+ * AXON Signal Codes for Skills (0x0050-0x005F range)
+ *
+ * Follows the DEPLOY_SIGNAL_CODES pattern from lib/deploy/provider.ts.
+ * Next available range after deploy's 0x0040-0x004F.
+ *
+ * @module skills/signals
+ */
+declare const SKILL_SIGNAL_CODES: {
+    /** Skill execution started */
+    readonly SKILL_START: 80;
+    /** Individual agent within skill started */
+    readonly SKILL_AGENT_START: 81;
+    /** Individual agent within skill completed */
+    readonly SKILL_AGENT_COMPLETE: 82;
+    /** An artifact has been produced */
+    readonly SKILL_ARTIFACT_READY: 83;
+    /** Progress update (percentage, current step) */
+    readonly SKILL_PROGRESS: 84;
+    /** Skill execution completed successfully */
+    readonly SKILL_COMPLETE: 85;
+    /** Skill execution paused — awaiting user gate decision */
+    readonly SKILL_GATE_PENDING: 86;
+    /** Peer review cycle triggered for an agent */
+    readonly SKILL_PEER_REVIEW: 87;
+    /** Dynamic delegation triggered by an agent */
+    readonly SKILL_DELEGATION: 88;
+    /** Agent output refinement iteration (convergence engine) */
+    readonly SKILL_AGENT_REFINE: 89;
+    /** Population selection round completed */
+    readonly SKILL_SELECTION: 90;
+    /** Backpressure event in skill chain */
+    readonly SKILL_BACKPRESSURE: 91;
+    /** Resource budget exceeded */
+    readonly SKILL_BUDGET_EXCEEDED: 92;
+    /** Skill execution error */
+    readonly SKILL_ERROR: 95;
 };
-declare function getActionBus(): TypedEventBus<ActionBusEvents>;
-declare function dispatchAction(event: ActionEvent): void;
-declare function onAction(handler: (event: ActionEvent) => void): () => void;
+type SkillSignalCode = (typeof SKILL_SIGNAL_CODES)[keyof typeof SKILL_SIGNAL_CODES];
+type SkillEventType = "skill:start" | "skill:agent_start" | "skill:agent_complete" | "skill:artifact_ready" | "skill:progress" | "skill:complete" | "skill:gate_pending" | "skill:peer_review" | "skill:delegation" | "skill:agent_refine" | "skill:selection" | "skill:backpressure" | "skill:budget_exceeded" | "skill:error";
 
 /**
- * Mesh SDK — Event emission, subscription, and query
+ * Skill SDK — Skill execution and management
  *
- * Cross-layer communication via signals and the action bus.
- * Hides Interaction primitive internals, SDKMessage, AXON internals.
+ * Skill types, registry access, and signal constants.
+ * Hides SkillManifest internals, runner pipeline, agent-executor, topo-sort.
  *
  * @copyright © 2026 Intuition Labs LLC. All rights reserved. Patent Pending.
- * @module sdk/mesh
- */
-
-type mesh_Action = Action;
-type mesh_ActionBinding = ActionBinding;
-type mesh_ActionBusEvents = ActionBusEvents;
-type mesh_ActionContext = ActionContext;
-type mesh_ActionEvent = ActionEvent;
-type mesh_InputSurface = InputSurface;
-type mesh_Signal<T = unknown> = Signal<T>;
-type mesh_SignalBus = SignalBus;
-type mesh_SignalHandler<T = unknown> = SignalHandler<T>;
-type mesh_SignalType = SignalType;
-declare const mesh_createSignalBus: typeof createSignalBus;
-declare const mesh_delegateAndWatch: typeof delegateAndWatch;
-declare const mesh_dispatchAction: typeof dispatchAction;
-declare const mesh_emitSignal: typeof emitSignal;
-declare const mesh_getActionBus: typeof getActionBus;
-declare const mesh_getSignalBus: typeof getSignalBus;
-declare const mesh_goAndRun: typeof goAndRun;
-declare const mesh_onAction: typeof onAction;
-declare const mesh_seq: typeof seq;
-declare const mesh_subscribeToSignals: typeof subscribeToSignals;
-declare namespace mesh {
-  export { type mesh_Action as Action, type mesh_ActionBinding as ActionBinding, type mesh_ActionBusEvents as ActionBusEvents, type mesh_ActionContext as ActionContext, type mesh_ActionEvent as ActionEvent, type mesh_InputSurface as InputSurface, type mesh_Signal as Signal, type mesh_SignalBus as SignalBus, type mesh_SignalHandler as SignalHandler, type mesh_SignalType as SignalType, mesh_createSignalBus as createSignalBus, mesh_delegateAndWatch as delegateAndWatch, mesh_dispatchAction as dispatchAction, mesh_emitSignal as emitSignal, mesh_getActionBus as getActionBus, mesh_getSignalBus as getSignalBus, mesh_goAndRun as goAndRun, mesh_onAction as onAction, mesh_seq as seq, mesh_subscribeToSignals as subscribeToSignals };
-}
+ * @module sdk/skill
+ */
+
+declare const skill_SKILL_CATEGORIES: typeof SKILL_CATEGORIES;
+declare const skill_SKILL_RANKS: typeof SKILL_RANKS;
+declare const skill_SKILL_RUN_STATUSES: typeof SKILL_RUN_STATUSES;
+declare const skill_SKILL_SIGNAL_CODES: typeof SKILL_SIGNAL_CODES;
+declare const skill_SKILL_TIERS: typeof SKILL_TIERS;
+type skill_SkillAgent = SkillAgent;
+type skill_SkillCapabilities = SkillCapabilities;
+type skill_SkillCategory = SkillCategory;
+type skill_SkillEventType = SkillEventType;
+type skill_SkillHealth = SkillHealth;
+type skill_SkillManifest<TInput extends Record<string, unknown> = Record<string, unknown>> = SkillManifest<TInput>;
+type skill_SkillMeta<TInput extends Record<string, unknown> = Record<string, unknown>> = SkillMeta<TInput>;
+type skill_SkillRank = SkillRank;
+type skill_SkillRunStatus = SkillRunStatus;
+type skill_SkillSignalCode = SkillSignalCode;
+type skill_SkillTier = SkillTier;
+declare const skill_ensureSkillsRegistered: typeof ensureSkillsRegistered;
+declare const skill_getAllSkills: typeof getAllSkills;
+declare const skill_getSkill: typeof getSkill;
+declare const skill_getSkillCount: typeof getSkillCount;
+declare const skill_getSkillsByCategory: typeof getSkillsByCategory;
+declare const skill_registerSkill: typeof registerSkill;
+declare namespace skill {
+  export { skill_SKILL_CATEGORIES as SKILL_CATEGORIES, skill_SKILL_RANKS as SKILL_RANKS, skill_SKILL_RUN_STATUSES as SKILL_RUN_STATUSES, skill_SKILL_SIGNAL_CODES as SKILL_SIGNAL_CODES, skill_SKILL_TIERS as SKILL_TIERS, type skill_SkillAgent as SkillAgent, type skill_SkillCapabilities as SkillCapabilities, type skill_SkillCategory as SkillCategory, type skill_SkillEventType as SkillEventType, type skill_SkillHealth as SkillHealth, type skill_SkillManifest as SkillManifest, type skill_SkillMeta as SkillMeta, type skill_SkillRank as SkillRank, type skill_SkillRunStatus as SkillRunStatus, type skill_SkillSignalCode as SkillSignalCode, type skill_SkillTier as SkillTier, skill_ensureSkillsRegistered as ensureSkillsRegistered, skill_getAllSkills as getAllSkills, skill_getSkill as getSkill, skill_getSkillCount as getSkillCount, skill_getSkillsByCategory as getSkillsByCategory, skill_registerSkill as registerSkill };
+}
+
+/**
+ * Manifold Annihilation API
+ *
+ * Converges an Intent Manifold and a Context Manifold via py2bend compilation
+ * and HVM reduction where available.
+ */
+
+interface AnnihilationOptions {
+    maxSteps?: number;
+    convergenceThreshold?: number;
+    gravity?: number;
+}
+interface ManifoldReductionMetrics {
+    compiled: boolean;
+    reduced: boolean;
+    strategy: string;
+    runtime: "wasm-hvm" | "compile-only";
+    durationMs: number;
+    warnings: string[];
+    errors: string[];
+    logitBias: Record<string, number>;
+}
+interface ManifoldSematonPayload {
+    result: string;
+    steps: number;
+    intent: string;
+    contextSnapshot: string;
+    bendCode?: string;
+    reduction: ManifoldReductionMetrics;
+}
+declare function annihilate(intent: string, context?: string, options?: AnnihilationOptions): Promise<Sematon<ManifoldSematonPayload>>;
+declare const manifold: {
+    annihilate: typeof annihilate;
+};
 
-type brain_CoherenceConfig = CoherenceConfig;
-type brain_CoherenceInput = CoherenceInput;
-type brain_CoherenceMetrics = CoherenceMetrics;
-type brain_CoherenceResult = CoherenceResult;
-type brain_KuramotoStepOptions = KuramotoStepOptions;
-type brain_OrderParameter = OrderParameter;
-declare const brain_calculateCoherence: typeof calculateCoherence;
-declare const brain_calculateCoherenceWithExplanations: typeof calculateCoherenceWithExplanations;
-declare const brain_getCoherenceSuggestions: typeof getCoherenceSuggestions;
-declare const brain_isCoherent: typeof isCoherent;
-declare const brain_kuramotoStep: typeof kuramotoStep;
-declare const brain_orderParameter: typeof orderParameter;
-declare const brain_phaseLockingValue: typeof phaseLockingValue;
-declare const brain_wrapTo2Pi: typeof wrapTo2Pi;
-declare const brain_wrapToPi: typeof wrapToPi;
-declare namespace brain {
-  export { type brain_CoherenceConfig as CoherenceConfig, type brain_CoherenceInput as CoherenceInput, type brain_CoherenceMetrics as CoherenceMetrics, type brain_CoherenceResult as CoherenceResult, type brain_KuramotoStepOptions as KuramotoStepOptions, type brain_OrderParameter as OrderParameter, brain_calculateCoherence as calculateCoherence, brain_calculateCoherenceWithExplanations as calculateCoherenceWithExplanations, brain_getCoherenceSuggestions as getCoherenceSuggestions, brain_isCoherent as isCoherent, brain_kuramotoStep as kuramotoStep, brain_orderParameter as orderParameter, brain_phaseLockingValue as phaseLockingValue, brain_wrapTo2Pi as wrapTo2Pi, brain_wrapToPi as wrapToPi };
+type manifold$1_AnnihilationOptions = AnnihilationOptions;
+type manifold$1_ManifoldReductionMetrics = ManifoldReductionMetrics;
+type manifold$1_ManifoldSematonPayload = ManifoldSematonPayload;
+declare const manifold$1_annihilate: typeof annihilate;
+declare const manifold$1_manifold: typeof manifold;
+declare namespace manifold$1 {
+  export { type manifold$1_AnnihilationOptions as AnnihilationOptions, type manifold$1_ManifoldReductionMetrics as ManifoldReductionMetrics, type manifold$1_ManifoldSematonPayload as ManifoldSematonPayload, manifold$1_annihilate as annihilate, manifold$1_manifold as manifold };
+}
+
+/**
+ * StateMirror - Total Context Encoding
+ *
+ * Continuously encodes the entire application, UI, and cognitive state into a
+ * shared representational manifold. This provides the ObserverKernel with literal
+ * environmental awareness, preventing "blind" execution.
+ */
+
+interface SystemStateSnapshot {
+    /** The current URL or deep-link active in the browser */
+    activeUrl: string;
+    /** The specific UI component currently focused or under cursor */
+    focusedComponent: string | null;
+    /** The last N intents expressed by the user */
+    recentIntents: string[];
+    /** Latest L1 AudioKernel spectral entropy [0,1] */
+    audioEntropy: number;
+    /** Whether the NanoFold 3D surface is actively rendering */
+    nanoFoldActive: boolean;
+    /** Current System Coherence R [0,1] */
+    coherenceR: number;
+    /** Current active project or workspace ID */
+    activeProject: string | null;
+}
+declare class StateMirror {
+    private state$;
+    private bridgeOwnerId;
+    private bridgeOrder;
+    constructor();
+    private initSubscriptions;
+    /** Gets the observable stream of state changes */
+    get stream$(): Observable<SystemStateSnapshot>;
+    /** Gets a synchronous snapshot of the current state */
+    get snapshot(): SystemStateSnapshot;
+    claimBridge(bridgeId: string): void;
+    releaseBridge(bridgeId: string): void;
+    /** Partially updates the mirror state */
+    update(partial: Partial<SystemStateSnapshot>): void;
+    /**
+     * Bridge-scoped update to prevent multiple mounted app shells from racing
+     * against the same singleton mirror.
+     */
+    updateFromBridge(bridgeId: string, partial: Partial<SystemStateSnapshot>): void;
+    /**
+     * Flattens the continuous state into a dense text manifold.
+     * This is passed to the ObserverKernel to ground it in the immediate UI/UX reality.
+     */
+    encodeToManifold(): string;
 }
 
 /**
- * Agent Communication Bus — in-memory message passing for skill agents.
+ * ObserverField & Neurons
  *
- * Scoped per skill run. Agents publish findings, review requests, and
- * delegation requests. Downstream agents receive accumulated context
- * via their system prompt.
+ * Formalization of the Terminals abstraction:
+ * The MicroLM is not a calculator. It is a continuous ObserverKernel.
+ * Skills are not apps. They are geometric Neurons equipped by the Observer.
  *
- * @module skills/agent-bus
+ * @module sdk/observer
  */
-type AgentMessageType = "finding" | "question" | "review_request" | "review_response" | "delegation_request" | "delegation_response";
-interface AgentMessage {
-    fromAgent: string;
-    toAgent?: string;
-    type: AgentMessageType;
-    payload: string;
-    timestamp: number;
-    runId: string;
-}
-type MessageHandler = (msg: AgentMessage) => void;
-interface AgentBus {
-    publish(msg: AgentMessage): void;
-    query(filter: {
-        fromAgent?: string;
-        type?: string;
-    }): AgentMessage[];
-    subscribe(agentId: string, handler: MessageHandler): () => void;
-    getAll(): AgentMessage[];
-}
+
 /**
- * Create an AgentBus scoped to a single skill run.
- * Messages are stored in-memory (array). No persistence needed —
- * the bus lifetime matches the SkillRunner instance.
+ * A hot-swappable structural template that the Observer equips to resolve intent.
  */
-declare function createAgentBus(runId: string): AgentBus;
-
+interface Neuron {
+    id: string;
+    kind: "skill" | "isomorphism" | "prompt-sensor" | "py2bend-template";
+    payload: unknown;
+    gravity: number;
+}
+interface ObserverConfig {
+    id: string;
+    heartbeatHz?: number;
+    stateMirror?: StateMirror;
+}
 /**
- * Protocol SDK — MCP and A2A protocol connections
- *
- * Delegation primitives and agent communication types.
- * Hides MCP client lifecycle, A2A internals.
+ * ObserverKernel - Continuous Local Witness
  *
- * @copyright © 2026 Intuition Labs LLC. All rights reserved. Patent Pending.
- * @module sdk/protocol
+ * An active, unbroken presence that maintains a heartbeat,
+ * observes the StateMirror, and equips Neurons (skills) dynamically.
  */
+declare class ObserverKernel {
+    readonly id: string;
+    readonly heartbeatHz: number;
+    private mirror;
+    private activeNeurons;
+    private coherenceR$;
+    private pulseTimer;
+    constructor(config: ObserverConfig);
+    get coherence(): number;
+    get isRunning(): boolean;
+    /** Starts the continuous heartbeat */
+    start(): void;
+    /** Stops the heartbeat */
+    stop(): void;
+    /** The continuous observation loop */
+    private pulse;
+    /** Equips a new geometric constraint (Neuron) onto the observer */
+    equipNeuron(neuron: Neuron): void;
+    /** Unequips a Neuron */
+    unequipNeuron(neuronId: string): void;
+    /** Replace the active neuron field in one operation. */
+    syncNeurons(neurons: Neuron[]): void;
+    /**
+     * The core execution path:
+     * Flattens the active Neurons + StateMirror context, then drops them into the Annihilator.
+     */
+    resolve(intent: string): Promise<Sematon<any>>;
+}
+declare function disposeObserverKernel(id: string): void;
+declare function getObserverKernel(id: string, config?: Omit<ObserverConfig, "id">): ObserverKernel;
 
-type protocol_AgentBus = AgentBus;
-type protocol_AgentMessage = AgentMessage;
-type protocol_AgentMessageType = AgentMessageType;
-type protocol_DelegationChain = DelegationChain;
-type protocol_DelegationEdge<S = SurfaceId, T = SurfaceId> = DelegationEdge<S, T>;
-type protocol_DelegationEdgeInput<S = SurfaceId, T = SurfaceId> = DelegationEdgeInput<S, T>;
-type protocol_DelegationEndpoint<S = SurfaceId> = DelegationEndpoint<S>;
-declare const protocol_createAgentBus: typeof createAgentBus;
-declare const protocol_createDelegationChain: typeof createDelegationChain;
-declare const protocol_createDelegationEdge: typeof createDelegationEdge;
-declare const protocol_isValidSurfaceId: typeof isValidSurfaceId;
-declare namespace protocol {
-  export { type protocol_AgentBus as AgentBus, type protocol_AgentMessage as AgentMessage, type protocol_AgentMessageType as AgentMessageType, type protocol_DelegationChain as DelegationChain, type protocol_DelegationEdge as DelegationEdge, type protocol_DelegationEdgeInput as DelegationEdgeInput, type protocol_DelegationEndpoint as DelegationEndpoint, protocol_createAgentBus as createAgentBus, protocol_createDelegationChain as createDelegationChain, protocol_createDelegationEdge as createDelegationEdge, protocol_isValidSurfaceId as isValidSurfaceId };
+type observer_Neuron = Neuron;
+type observer_ObserverConfig = ObserverConfig;
+type observer_ObserverKernel = ObserverKernel;
+declare const observer_ObserverKernel: typeof ObserverKernel;
+declare const observer_disposeObserverKernel: typeof disposeObserverKernel;
+declare const observer_getObserverKernel: typeof getObserverKernel;
+declare namespace observer {
+  export { type observer_Neuron as Neuron, type observer_ObserverConfig as ObserverConfig, observer_ObserverKernel as ObserverKernel, observer_disposeObserverKernel as disposeObserverKernel, observer_getObserverKernel as getObserverKernel };
 }
 
 /**
@@ -3543,6 +3809,6 @@ declare function createAxonBus(): InMemoryAxonBus;
  *
  * Curated package facade for the npm package.
  */
-declare const SDK_VERSION = "1.0.0-rc.1";
+declare const SDK_VERSION = "1.0.0";
 
-export { type AxonMessage, type AxonMessageBus, brain as Brain, type CoherenceConfig, type CoherenceInput, type CoherenceMetrics, type CoherenceResult, core as Core, InMemoryAxonBus, type KuramotoStepOptions, index as L0, mesh as Mesh, type OrderParameter, protocol as Protocol, ProtocolBridge, SDK_VERSION, terminal as Terminal, calculateCoherence, calculateCoherenceWithExplanations, createAxonBus, createProtocolBridge, getCoherenceSuggestions, isCoherent, kuramotoStep, orderParameter, phaseLockingValue, wrapTo2Pi, wrapToPi };
+export { type AxonMessage, type AxonMessageBus, brain as Brain, core as Core, InMemoryAxonBus, index as L0, manifold$1 as Manifold, mesh as Mesh, observer as Observer, protocol as Protocol, ProtocolBridge, SDK_VERSION, skill as Skill, terminal as Terminal, createAxonBus, createProtocolBridge };