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

package/dist/index.d.ts

@@ -549,6 +549,16 @@ 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
+ */
+
 type CoherenceMetrics = CoherenceMetrics$1;
 /**
  * Enhanced coherence result with human-readable explanations
@@ -1015,7 +1025,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,677 +1483,159 @@ 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";
+/**
+ * Layer metadata
+ */
+interface LayerMeta {
+    id: LayerId;
+    name: string;
+    description: string;
+    color: string;
 }
 /**
- * Manifest layer provenance.
- *
- * - `L0`: Landing/Zero layer (low-level primitives)
- * - `L1`: Compose/Platform layer (higher-level abstractions)
+ * AXON Layer definitions
  */
-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 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;
-}
-
-/**
- * Skill Manifest Types (L1)
- *
- * Core types for the Skills Platform. A SkillManifest extends StackManifestV0
- * with skill-specific metadata — a skill IS a stack with agent orchestration.
- *
- * @module skills/types
- */
-
-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.
- */
-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;
-}
-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";
-    };
-}
-/**
- * A SkillManifest extends StackManifestV0 with skill-specific metadata.
- *
- * This is the core type — a skill IS a stack manifest with agent orchestration
- * metadata. The `skill` field contains all presentation and execution metadata.
- *
- * The `TInput` parameter establishes compile-time correspondence between
- * the JSON Schema `inputSchema`, the typed `sampleInput`, and the runtime
- * input validated by `SkillRunner.start()`.
- */
-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;
-
-/**
- * Core SDK — Fundamental utilities and data structures
- *
- * Result types, retry/circuit-breaker, event bus, validation, DAG, registry.
- * Hides internal combinators, vector ops, stream internals.
- *
- * @copyright © 2026 Intuition Labs LLC. All rights reserved. Patent Pending.
- * @module sdk/core
- */
-
-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 };
-}
-
-/**
- * L0 Category Theory Primitives
- *
- * Foundational categorical abstractions for cross-layer type mappings.
- * Provides the mathematical foundation for isomorphisms between AXON layers.
- *
- * @license BUSL-1.1
- * @copyright © 2026 Intuition Labs LLC. All rights reserved. Patent Pending.
- * @module core/L0/category
- */
-/**
- * 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;
-}
-/**
- * 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 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;
-}
-/**
- * Metadata about an isomorphism
- */
-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;
-}
-/**
- * AXON Layer definitions
- */
-declare const LAYERS: Record<LayerId, LayerMeta>;
+declare const LAYERS: Record<LayerId, LayerMeta>;
 /**
  * Valid layer transitions in the AXON architecture
  */
@@ -2250,818 +1742,1286 @@ declare function entropy(probabilities: number[]): number;
  * @param jointProbabilities - 2D array of joint probabilities P(X=x, Y=y)
  * @returns Joint entropy in bits
  */
-declare function jointEntropy(jointProbabilities: number[][]): number;
+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;
+}
+/**
+ * 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;
+}
+/**
+ * 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
+ */
+declare function estimateComplexity(data: string): number;
+/**
+ * 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)
+ */
+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)
+ *
+ * @param p - First distribution
+ * @param q - Second distribution
+ * @returns JS divergence in [0, 1]
+ */
+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 Automatic Isomorphism Derivation
+ *
+ * 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/derivation
+ */
+
+/**
+ * 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;
+}
+/**
+ * Extract the structural shape of a value at runtime
+ *
+ * @param value - Value to analyze
+ * @returns TypeShape descriptor
+ */
+declare function extractShape(value: unknown): TypeShape;
+/**
+ * Calculate similarity between two type shapes (Jaccard-like)
+ *
+ * @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
+ */
+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>;
+}
+/**
+ * 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;
+}
+/**
+ * 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>>;
+}
+/**
+ * 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
+ *
+ * @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)
+ *
+ * @param source - Source type shape
+ * @param target - Target type shape
+ * @returns True if source can be fully embedded in target
+ */
+declare function canEmbed(source: TypeShape, target: TypeShape): boolean;
+
 /**
- * Calculate conditional entropy H(Y|X) = H(X,Y) - H(X)
+ * L0 Sematon — The Smallest Meaning-Bearing Unit
  *
- * @param jointProbabilities - 2D array P(X=x, Y=y)
- * @returns Conditional entropy in bits
+ * 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 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
+ * Payload kind classification for sematons.
+ * Determines how the payload is interpreted across layers.
  */
-declare function mutualInformation(pX: number[], pY: number[], pXY: number[][]): number;
+type SematonKind = "signal" | "context" | "fractal" | "witness" | "combinator" | "interaction" | "custom";
 /**
- * Metrics for measuring information preservation in transformations
+ * Convergence witness snapshot embedded in a sematon.
+ * Minimal subset of ConvergenceWitness for portability.
  */
-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 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;
 }
 /**
- * Measure information preservation between source and transformed representations.
- * Uses hash-based sampling for large datasets.
+ * The Sematon — smallest meaning-bearing unit with operational consequence.
  *
- * @param source - Original values
- * @param transformed - Transformed values
- * @param roundTrip - Optional round-trip values (transformed → source)
- * @returns Information preservation metrics
+ * 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
  */
-declare function measurePreservation<S, T>(source: S[], transformed: T[], roundTrip?: S[]): InformationPreservation;
+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;
+}
 /**
- * Semantic density measures bits of meaningful information per token.
- * Higher density = more information packed into fewer tokens.
+ * Folded (serializable) representation of a Sematon.
+ * Suitable for JSON serialization, mesh relay, or persistence.
  */
-interface SemanticDensity {
-    /** Total tokens in the representation */
-    tokenCount: number;
-    /** Estimated information content in bits */
-    informationBits: number;
-    /** Bits per token */
+interface FoldedSematon {
+    id: string;
+    kind: SematonKind;
+    payload: string;
+    witness: SematonWitness;
+    padicAddress: string;
+    entropy: number;
     density: number;
-    /** Compression ratio compared to baseline */
-    compressionRatio: number;
+    impedance: number;
+    shapeHash: string;
+    constructive: boolean;
+    createdAt: number;
+    source: string;
+}
+interface SematonConfig<T> {
+    kind: SematonKind;
+    payload: T;
+    witness: SematonWitness;
+    padicAddress?: string;
+    source?: string;
 }
 /**
- * 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
+ * Create a new Sematon from configuration.
  */
-declare function calculateSemanticDensity(tokens: string[], baselineTokensPerBit?: number): SemanticDensity;
+declare function createSematon<T>(config: SematonConfig<T>): Sematon<T>;
 /**
- * Estimate Kolmogorov complexity via compression.
- * Lower complexity = more compressible = more structured.
- *
- * @param data - String representation of data
- * @returns Estimated complexity as compression ratio
+ * Get the Shannon entropy of a sematon's payload.
  */
-declare function estimateComplexity(data: string): number;
+declare function sematonEntropy<T>(sematon: Sematon<T>): number;
 /**
- * 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)
+ * Get the semantic density of a sematon.
  */
-declare function klDivergence(p: number[], q: number[]): number;
+declare function sematonDensity<T>(sematon: Sematon<T>): 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)
+ * Check if a sematon can participate in further transformations.
+ * This is the Deutsch-Marletto constructor invariant.
+ */
+declare function isRealizable<T>(sematon: Sematon<T>): boolean;
+/**
+ * Compute distance between two sematons using payload cosine similarity
+ * weighted by witness R proximity.
  *
- * @param p - First distribution
- * @param q - Second distribution
- * @returns JS divergence in [0, 1]
+ * Distance in [0, 1] where 0 = identical, 1 = maximally different.
  */
-declare function jsDivergence(p: number[], q: number[]): number;
+declare function sematonDistance<T>(a: Sematon<T>, b: Sematon<T>): number;
 /**
- * Normalize an array to sum to 1 (probability distribution)
+ * Fold a Sematon into a JSON-serializable representation.
+ * HVM γ (construct) — compress for handoff, persistence, or relay.
  */
-declare function normalize(values: number[]): number[];
+declare function foldSematon<T>(sematon: Sematon<T>): FoldedSematon;
 /**
- * Calculate cosine similarity between two vectors
+ * Unfold a serialized representation back into a Sematon.
+ * HVM δ (duplicate) — expand from handoff, persistence, or relay.
  */
-declare function cosineSimilarity(a: number[], b: number[]): number;
+declare function unfoldSematon<T>(folded: FoldedSematon): Sematon<T>;
 
 /**
- * L0 Automatic Isomorphism Derivation
+ * L0 Realizability Trace — Constructor Proof Runtime
  *
- * Automatically derives isomorphisms between compatible types
- * using structural analysis and field mapping.
+ * A RealizabilityTrace is an ordered sequence of RealizabilitySteps.
+ * Each step records: input Sematon(s), output Sematon(s), a ConvergenceWitness
+ * snapshot, and information gain.
+ *
+ * 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
+ *
+ * This is the Deutsch-Marletto constructor invariant made executable:
+ * after transforming inputs, the system retains the ability to transform again.
  *
  * @license BUSL-1.1
  * @copyright © 2026 Intuition Labs LLC. All rights reserved. Patent Pending.
- * @module core/L0/derivation
+ * @module core/L0/realizability
  */
 
+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 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;
 /**
- * Type shape descriptor for structural analysis
+ * Create a single realizability step.
+ * Computes informationGain as the sum of output sematon entropies.
  */
-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;
-}
+declare function createRealizabilityStep(index: number, inputs: Sematon[], outputs: Sematon[], witness: SematonWitness): RealizabilityStep;
+/**
+ * Construct a RealizabilityTrace from an ordered sequence of steps.
+ * Computes totalInfoGain and constructiveSteps.
+ */
+declare function traceRealizability(steps: RealizabilityStep[]): RealizabilityTrace;
 /**
- * Extract the structural shape of a value at runtime
+ * 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 value - Value to analyze
- * @returns TypeShape descriptor
+ * Returns VerificationSuccess or VerificationFailure with step index and reason.
  */
-declare function extractShape(value: unknown): TypeShape;
+declare function verifyTrace(trace: RealizabilityTrace): VerificationResult;
 /**
- * Calculate similarity between two type shapes (Jaccard-like)
- *
- * @param a - First type shape
- * @param b - Second type shape
- * @returns Similarity score (0-1)
+ * Fold a RealizabilityTrace into a JSON string.
+ * Sematons are folded via foldSematon first for portable serialization.
  */
-declare function shapeSimilarity(a: TypeShape, b: TypeShape): number;
+declare function foldTrace(trace: RealizabilityTrace): string;
 /**
- * A mapping between fields in source and target types
+ * Unfold a JSON string back into a RealizabilityTrace.
+ * Sematons are unfolded via unfoldSematon.
  */
-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>;
-}
+declare function unfoldTrace(json: string): RealizabilityTrace;
+
 /**
- * Derive field mappings between two object shapes
+ * L0 Foundation Layer
  *
- * @param source - Source type shape
- * @param target - Target type shape
- * @returns Array of field mappings
+ * Provides categorical foundations and information-theoretic primitives
+ * for cross-layer mappings in the AXON architecture.
+ *
+ * @module core/L0
  */
-declare function deriveFieldMappings(source: TypeShape, target: TypeShape): FieldMapping[];
+
+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 };
+}
+
 /**
- * Result of automatic isomorphism derivation
+ * 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
  */
-interface DerivedIso<A, B> extends Iso<A, B> {
-    /** Field mappings used */
-    fieldMappings: FieldMapping[];
-    /** Overall confidence score */
-    confidence: number;
+
+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 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";
 }
-/**
- * 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 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.
- */
-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;
-}
-/**
- * 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;
-}
-/**
- * Folded (serializable) representation of a Sematon.
- * Suitable for JSON serialization, mesh relay, or persistence.
+ * @module sdk/mesh
  */
-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;
+
+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 };
 }
-/**
- * Create a new Sematon from configuration.
- */
-declare function createSematon<T>(config: SematonConfig<T>): Sematon<T>;
-/**
- * Get the Shannon entropy of a sematon's payload.
- */
-declare function sematonEntropy<T>(sematon: Sematon<T>): number;
-/**
- * Get the semantic density of a sematon.
- */
-declare function sematonDensity<T>(sematon: Sematon<T>): number;
-/**
- * Check if a sematon can participate in further transformations.
- * This is the Deutsch-Marletto constructor invariant.
- */
-declare function isRealizable<T>(sematon: Sematon<T>): boolean;
-/**
- * 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 sematonDistance<T>(a: Sematon<T>, b: Sematon<T>): number;
-/**
- * Fold a Sematon into a JSON-serializable representation.
- * HVM γ (construct) — compress for handoff, persistence, or relay.
- */
-declare function foldSematon<T>(sematon: Sematon<T>): FoldedSematon;
-/**
- * Unfold a serialized representation back into a Sematon.
- * HVM δ (duplicate) — expand from handoff, persistence, or relay.
- */
-declare function unfoldSematon<T>(folded: FoldedSematon): Sematon<T>;
 
-/**
- * L0 Realizability Trace — Constructor Proof Runtime
- *
- * A RealizabilityTrace is an ordered sequence of RealizabilitySteps.
- * Each step records: input Sematon(s), output Sematon(s), a ConvergenceWitness
- * snapshot, and information gain.
- *
- * 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
+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 };
+}
+
+/**
+ * Agent Communication Bus — in-memory message passing for skill agents.
  *
- * This is the Deutsch-Marletto constructor invariant made executable:
- * after transforming inputs, the system retains the ability to transform again.
+ * Scoped per skill run. Agents publish findings, review requests, and
+ * delegation requests. Downstream agents receive accumulated context
+ * via their system prompt.
  *
- * @license BUSL-1.1
- * @copyright © 2026 Intuition Labs LLC. All rights reserved. Patent Pending.
- * @module core/L0/realizability
+ * @module skills/agent-bus
  */
-
-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 */
+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;
 }
-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 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[];
 }
-type VerificationResult = VerificationSuccess | VerificationFailure;
 /**
- * Create a single realizability step.
- * Computes informationGain as the sum of output sematon entropies.
+ * 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 createRealizabilityStep(index: number, inputs: Sematon[], outputs: Sematon[], witness: SematonWitness): RealizabilityStep;
+declare function createAgentBus(runId: string): AgentBus;
+
 /**
- * Construct a RealizabilityTrace from an ordered sequence of steps.
- * Computes totalInfoGain and constructiveSteps.
+ * 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 traceRealizability(steps: RealizabilityStep[]): RealizabilityTrace;
+
+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 NodePolicy = NodePolicy$1;
+type StackPolicies = StackPolicies$1;
 /**
- * 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
+ * Runtime tier for node execution.
  *
- * Returns VerificationSuccess or VerificationFailure with step index and reason.
+ * 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
+ *
+ * @example
+ * const tier: RuntimeTier = "worker";
  */
-declare function verifyTrace(trace: RealizabilityTrace): VerificationResult;
+type RuntimeTier = "worker" | "container-lite" | "webcontainer" | "edge" | "wasm-hvm" | "stack";
 /**
- * Fold a RealizabilityTrace into a JSON string.
- * Sematons are folded via foldSematon first for portable serialization.
+ * Base manifest fields shared by nodes and stacks.
+ *
+ * @internal
  */
-declare function foldTrace(trace: RealizabilityTrace): string;
+interface BaseManifestV0 {
+    /** Unique identifier (must be stable across versions) */
+    id: string;
+    /** 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>;
+}
 /**
- * Unfold a JSON string back into a RealizabilityTrace.
- * Sematons are unfolded via unfoldSematon.
+ * Stack-level secret scope definition.
+ *
+ * Defines which nodes can access a secret.
+ *
+ * @example
+ * const secretScope: StackSecretScope = {
+ *   scope: ["fetch-node", "transform-node"],
+ *   required: true
+ * };
  */
-declare function unfoldTrace(json: string): RealizabilityTrace;
-
+interface StackSecretScope {
+    /** Node IDs that can access this secret */
+    scope: string[];
+    /** Whether secret must exist */
+    required?: boolean;
+}
 /**
- * L0 Foundation Layer
+ * Stack-level runtime tier configuration.
  *
- * Provides categorical foundations and information-theoretic primitives
- * for cross-layer mappings in the AXON architecture.
+ * Allows stack-wide defaults with per-node overrides.
  *
- * @module core/L0
- */
-
-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 };
+ * @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[]>;
 }
-
 /**
- * Action Algebra — Input-Agnostic Action Types
+ * Node configuration within a stack.
  *
- * All input surfaces (keyboard, gamepad, voice, touch) compile down to this algebra.
- * All executors interpret this algebra into effects.
+ * References a node manifest and provides instance-specific config.
  *
- * @module core/primitives/action
+ * @example
+ * const nodeConfig: StackNodeConfig = {
+ *   id: "fetch-1",
+ *   nodeRef: "http-fetch",
+ *   config: { timeout: 5000 },
+ *   runtimes: ["edge"],
+ *   secrets: ["api_key"]
+ * };
  */
-
-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";
+interface StackNodeConfig {
+    /** Unique ID within stack */
     id: string;
-} | {
-    kind: "command";
-    commandId: string;
-};
-interface ComposeEdge {
-    sourceId: string;
-    targetId: string;
-    port?: 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 ObserveTarget = {
-    kind: "metric";
-    metricId: string;
-} | {
-    kind: "panel";
-    panelId: string;
-} | {
-    kind: "surface";
-    surface: SurfaceId;
-};
-interface DelegateAssignment {
-    agentId: string;
-    taskDescription: string;
-    context?: Record<string, unknown>;
+/**
+ * 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" }
+ * };
+ */
+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 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[];
+/**
+ * Manifest layer provenance.
+ *
+ * - `L0`: Landing/Zero layer (low-level primitives)
+ * - `L1`: Compose/Platform layer (higher-level abstractions)
+ */
+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 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;
 }
-interface ActionContext {
-    activeSurface: SurfaceId;
-    activeTab: string;
-    selection: string[];
-    isTextFocused: boolean;
-    isModalOpen: boolean;
+
+/**
+ * Skill Manifest Types (L1)
+ *
+ * Core types for the Skills Platform. A SkillManifest extends StackManifestV0
+ * with skill-specific metadata — a skill IS a stack with agent orchestration.
+ *
+ * @module skills/types
+ */
+
+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;
 }
-type ActionPredicate = (ctx: ActionContext) => boolean;
-interface KeyboardTrigger {
-    type: "chord" | "key" | "sequence";
-    keys: string[];
-    timeout?: number;
+/**
+ * Promotion proof — the Curry-Howard witness type.
+ * Each promotion requires structural evidence that the entity
+ * satisfies the invariants of the target rank.
+ */
+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;
 }
-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 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;
 }
-interface VoiceTrigger {
-    type: "intent";
-    patterns: string[];
-    confidenceThreshold?: 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 TouchTrigger {
-    type: "gesture";
-    gesture: "swipe_left" | "swipe_right" | "swipe_up" | "swipe_down" | "pinch_in" | "pinch_out" | "long_press" | "double_tap" | "three_finger_swipe";
+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;
 }
-type InputTrigger = KeyboardTrigger | GamepadTrigger | VoiceTrigger | TouchTrigger;
-interface ActionBinding {
-    id: string;
-    action: Action;
+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;
-    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[];
 }
-/** 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
- *
- * All input surfaces publish ActionEvents here.
- * The executor and any observers subscribe here.
- *
- * @module core/primitives/action-bus
- */
-
-type ActionBusEvents = {
-    "action:dispatched": ActionEvent;
-    "action:executed": ActionEvent & {
-        result: "success" | "error";
-        error?: string;
-    };
-    "action:cancelled": {
-        reason: string;
-        timestamp: number;
+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";
     };
-    "context:changed": ActionContext;
-};
-declare function getActionBus(): TypedEventBus<ActionBusEvents>;
-declare function dispatchAction(event: ActionEvent): void;
-declare function onAction(handler: (event: ActionEvent) => void): () => void;
-
-/**
- * Mesh SDK — Event emission, subscription, and query
- *
- * Cross-layer communication via signals and the action bus.
- * Hides Interaction primitive internals, SDKMessage, AXON internals.
- *
- * @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 };
-}
-
-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 };
 }
-
 /**
- * Agent Communication Bus — in-memory message passing for skill agents.
+ * A SkillManifest extends StackManifestV0 with skill-specific metadata.
  *
- * Scoped per skill run. Agents publish findings, review requests, and
- * delegation requests. Downstream agents receive accumulated context
- * via their system prompt.
+ * 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 skills/agent-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 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[];
+interface SkillManifest<TInput extends Record<string, unknown> = Record<string, unknown>> extends StackManifestV0 {
+    /** Skill-specific metadata */
+    skill: SkillMeta<TInput>;
 }
-/**
- * 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 createAgentBus(runId: string): AgentBus;
+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;
+};
+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";
 
 /**
- * Protocol SDK — MCP and A2A protocol connections
+ * Skill SDK — Skill execution and management
  *
- * Delegation primitives and agent communication types.
- * Hides MCP client lifecycle, A2A 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/protocol
- */
-
-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 };
+ * @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 };
 }
 
 /**
@@ -3545,4 +3505,4 @@ declare function createAxonBus(): InMemoryAxonBus;
  */
 declare const SDK_VERSION = "1.0.0-rc.1";
 
-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, mesh as Mesh, protocol as Protocol, ProtocolBridge, SDK_VERSION, skill as Skill, terminal as Terminal, createAxonBus, createProtocolBridge };