diff --git a/packages/foundation/types/src/plugin.ts b/packages/foundation/types/src/plugin.ts
index 7a07484e..6430afb1 100644
--- a/packages/foundation/types/src/plugin.ts
+++ b/packages/foundation/types/src/plugin.ts
@@ -7,8 +7,77 @@
  */
 
 import { IObjectQL } from './app';
+import { UnifiedQuery } from './query';
 
 export interface ObjectQLPlugin {
     name: string;
     setup(app: IObjectQL): void | Promise<void>;
 }
+
+/**
+ * Plugin metadata for dependency management and lifecycle
+ */
+export interface PluginMetadata {
+    /** Unique plugin name */
+    name: string;
+    /** Plugin version (semver format) */
+    version?: string;
+    /** Plugin type classification */
+    type?: 'driver' | 'repository' | 'query_processor' | 'extension';
+    /** Plugin dependencies (plugin names that must be loaded first) */
+    dependencies?: string[];
+}
+
+/**
+ * Base plugin interface with lifecycle and dependency support
+ */
+export interface BasePlugin {
+    /** Plugin metadata */
+    readonly metadata: PluginMetadata;
+    
+    /** Setup hook called during plugin initialization */
+    setup?(runtime: any): void | Promise<void>;
+    
+    /** Teardown hook called during plugin shutdown */
+    teardown?(): void | Promise<void>;
+}
+
+/**
+ * Context provided to query processor plugins
+ */
+export interface QueryProcessorContext {
+    /** The object being queried */
+    objectName: string;
+    /** Current user/session context */
+    user?: {
+        id: string | number;
+        [key: string]: any;
+    };
+    /** Additional runtime context */
+    [key: string]: any;
+}
+
+/**
+ * Plugin interface for query processing pipeline
+ */
+export interface QueryProcessorPlugin extends BasePlugin {
+    metadata: PluginMetadata & { type: 'query_processor' };
+    
+    /** 
+     * Validate query before execution
+     * Can throw errors to reject the query
+     */
+    validateQuery?(query: UnifiedQuery, context: QueryProcessorContext): void | Promise<void>;
+    
+    /** 
+     * Transform query before execution
+     * Returns modified query (async waterfall pattern)
+     */
+    beforeQuery?(query: UnifiedQuery, context: QueryProcessorContext): UnifiedQuery | Promise<UnifiedQuery>;
+    
+    /** 
+     * Process results after query execution
+     * Returns modified results (async waterfall pattern)
+     */
+    afterQuery?(results: any[], context: QueryProcessorContext): any[] | Promise<any[]>;
+}
diff --git a/packages/runtime/core/ARCHITECTURE.md b/packages/runtime/core/ARCHITECTURE.md
new file mode 100644
index 00000000..90086620
--- /dev/null
+++ b/packages/runtime/core/ARCHITECTURE.md
@@ -0,0 +1,185 @@
+# Runtime Core Architecture
+
+## Overview
+
+The `@objectql/runtime-core` package implements the core plugin system and query pipeline for ObjectQL, following the principle of **Protocol/Spec vs Runtime/Implementation** separation.
+
+## Architecture Principles
+
+### 1. Protocol Layer (from `@objectql/types`)
+- **BasePlugin**: Interface defining plugin structure with metadata and lifecycle
+- **QueryProcessorPlugin**: Interface for plugins that process queries
+- **PluginMetadata**: Standardized plugin information including dependencies
+
+### 2. Runtime Layer (this package)
+- **PluginManager**: Implements dependency resolution and lifecycle management
+- **QueryPipeline**: Implements async series waterfall query processing
+- **Runtime**: Orchestrates plugins and provides query execution
+
+## Key Components
+
+### PluginManager
+
+**Responsibilities:**
+- Register plugins
+- Resolve dependencies using topological sort
+- Boot plugins in dependency order
+- Manage plugin lifecycle (setup/teardown)
+
+**Algorithm: Topological Sort**
+```typescript
+// Ensures dependencies are initialized before dependents
+// Detects circular dependencies
+// Throws errors for missing dependencies
+```
+
+**Example:**
+```typescript
+const manager = new PluginManager();
+manager.register(pluginA); // No dependencies
+manager.register(pluginB); // Depends on A
+manager.register(pluginC); // Depends on B
+
+await manager.boot(runtime);
+// Execution order: A → B → C
+```
+
+### QueryPipeline
+
+**Responsibilities:**
+- Execute queries through registered processors
+- Implement async series waterfall pattern
+- Validate queries before execution
+- Transform queries and results through plugin chain
+
+**Execution Flow:**
+```
+1. validateQuery (all plugins)
+   ↓
+2. beforeQuery (waterfall: plugin1 → plugin2 → ...)
+   ↓
+3. execute (driver)
+   ↓
+4. afterQuery (waterfall: plugin1 → plugin2 → ...)
+   ↓
+5. return results
+```
+
+**Waterfall Pattern:**
+- Each plugin receives output from previous plugin
+- Plugins can transform queries/results
+- Final output is returned to caller
+
+**Example:**
+```typescript
+// Plugin 1 adds field
+beforeQuery(query) {
+  return { ...query, fields: ['id', 'name'] };
+}
+
+// Plugin 2 adds filter (receives plugin 1's output)
+beforeQuery(query) {
+  return { ...query, filters: [['active', '=', true]] };
+}
+
+// Final query: { fields: ['id', 'name'], filters: [['active', '=', true]] }
+```
+
+### Runtime
+
+**Responsibilities:**
+- Provide factory function `createRuntime()`
+- Manage plugin manager and query pipeline
+- Expose simple API for query execution
+- Handle initialization and shutdown
+
+**API:**
+```typescript
+interface Runtime {
+  pluginManager: PluginManager;
+  init(): Promise<void>;
+  query(object, query, context): Promise<any[]>;
+  shutdown(): Promise<void>;
+  setQueryExecutor(executor): void;
+}
+```
+
+## Usage Pattern
+
+```typescript
+// 1. Define plugins
+const myPlugin: BasePlugin = {
+  metadata: {
+    name: 'my-plugin',
+    dependencies: ['base-plugin']
+  },
+  async setup(runtime) {
+    // Initialize plugin
+  }
+};
+
+// 2. Create runtime
+const runtime = createRuntime({
+  plugins: [myPlugin]
+});
+
+// 3. Set executor
+runtime.setQueryExecutor(async (object, query) => {
+  // Execute query against database
+});
+
+// 4. Initialize
+await runtime.init();
+
+// 5. Execute queries
+const results = await runtime.query('project', {
+  filters: [['status', '=', 'active']]
+});
+
+// 6. Shutdown
+await runtime.shutdown();
+```
+
+## Design Decisions
+
+### 1. Separation of Concerns
+- **Types** define interfaces (what)
+- **Runtime** implements logic (how)
+- No circular dependencies between packages
+
+### 2. Topological Sort for Dependencies
+- Ensures correct initialization order
+- Detects circular dependencies early
+- Provides clear error messages
+
+### 3. Async Series Waterfall
+- Allows plugins to transform data sequentially
+- Each plugin sees previous plugin's changes
+- Enables powerful composition patterns
+
+### 4. Error Handling
+- Custom error types (PluginError, PipelineError)
+- Include plugin name in errors for debugging
+- Graceful shutdown even if teardown fails
+
+## Testing
+
+The package includes 39 tests covering:
+- Plugin registration and lifecycle
+- Dependency resolution (simple, complex, diamond, circular)
+- Query pipeline execution (validation, waterfall, errors)
+- Integration scenarios
+
+Run tests:
+```bash
+pnpm test
+```
+
+## Future Enhancements
+
+Potential improvements:
+1. Plugin versioning and compatibility checking
+2. Hot plugin reload
+3. Plugin communication via events
+4. Performance monitoring hooks
+5. Plugin sandboxing for security
diff --git a/packages/runtime/core/IMPLEMENTATION_SUMMARY.md b/packages/runtime/core/IMPLEMENTATION_SUMMARY.md
new file mode 100644
index 00000000..163cc364
--- /dev/null
+++ b/packages/runtime/core/IMPLEMENTATION_SUMMARY.md
@@ -0,0 +1,198 @@
+# Implementation Summary: Runtime Plugin System
+
+## Problem Statement (Translated)
+
+The task was to implement a **Runtime Plugin System and Query Executor** in `packages/core/runtime` (implemented as `packages/runtime/core`), following the principle of separating **Protocol/Spec Layer** from **Runtime/Implementation Layer**.
+
+## What Was Implemented
+
+### 1. Type Extensions (`@objectql/types`)
+
+Extended the existing type system with:
+- **`BasePlugin`**: Interface with metadata, dependencies, and lifecycle hooks
+- **`QueryProcessorPlugin`**: Interface for plugins that intercept and transform queries
+- **`PluginMetadata`**: Standard metadata format including name, version, type, and dependencies
+
+### 2. Runtime Core Package (`@objectql/runtime-core`)
+
+Created a new package with three main components:
+
+#### **PluginManager**
+- Plugin registration with duplicate detection
+- Dependency resolution using **topological sort algorithm**
+- Circular dependency detection
+- Missing dependency validation
+- Lifecycle management (setup in dependency order, teardown in reverse order)
+
+**Key Algorithm:**
+```
+For each plugin:
+  1. Visit dependencies first (depth-first)
+  2. Detect cycles by tracking "visiting" state
+  3. Add to ordered list after all dependencies processed
+Result: Plugins sorted by dependency order
+```
+
+#### **QueryPipeline**
+- Implements **Async Series Waterfall** pattern
+- Three-phase execution:
+  1. **Validation**: All plugins validate the query
+  2. **beforeQuery**: Waterfall transformation (each plugin receives previous output)
+  3. **afterQuery**: Waterfall transformation of results
+
+**Key Pattern:**
+```
+Initial Query → Plugin1.beforeQuery → Plugin2.beforeQuery → ... → Final Query
+Execute Query
+Initial Results → Plugin1.afterQuery → Plugin2.afterQuery → ... → Final Results
+```
+
+#### **Runtime Factory**
+- `createRuntime(config)` factory function
+- Simple API for initialization and query execution
+- Integration of PluginManager and QueryPipeline
+- Graceful shutdown support
+
+### 3. Comprehensive Testing
+
+39 unit tests covering:
+- Plugin registration and lifecycle
+- Simple, complex, and diamond dependency graphs
+- Circular dependency detection
+- Query pipeline execution phases
+- Waterfall transformation
+- Error handling
+- Integration scenarios
+
+**Test Results:** ✅ 39/39 passing
+
+### 4. Documentation
+
+- **README.md**: Quick start and usage examples
+- **ARCHITECTURE.md**: Design decisions, patterns, and principles
+- **demo.ts**: Working example demonstrating all features
+
+## Key Design Decisions
+
+### 1. Separation of Concerns
+- **Types package**: Defines interfaces (protocol/contract)
+- **Runtime package**: Implements logic (runtime/implementation)
+- No circular dependencies
+
+### 2. Topological Sort for Dependencies
+- **Why**: Ensures correct initialization order automatically
+- **Benefit**: Developers don't need to manually order plugins
+- **Safety**: Detects circular dependencies early with clear error messages
+
+### 3. Async Series Waterfall
+- **Why**: Allows plugins to see and modify each other's changes
+- **Benefit**: Enables powerful composition patterns
+- **Example**: Security plugin adds tenant filter, cache plugin adds caching headers
+
+### 4. Error Handling
+- Custom error types (`PluginError`, `PipelineError`)
+- Include plugin name in errors for easy debugging
+- Graceful shutdown even if plugins fail
+
+## Demo Output
+
+```
+=== ObjectQL Runtime Core Demo ===
+
+1. Initializing runtime...
+[Logger] Plugin initialized
+[Security] Plugin initialized  
+[Cache] Plugin initialized (after logger)
+
+2. Executing query through pipeline...
+[Security] User user-123 executing query
+[Driver] Executing query on project: {
+  fields: [ 'id', 'name' ],
+  filters: [ 
+    [ 'status', '=', 'active' ], 
+    [ 'tenant_id', '=', 'tenant-1' ]  // Added by security plugin
+  ]
+}
+
+3. Results: [ { id: 1, name: 'Project 1', tenant_id: 'tenant-1' } ]
+
+4. Shutting down runtime...
+
+=== Demo Complete ===
+```
+
+## Files Created
+
+```
+packages/foundation/types/src/plugin.ts          (+69 lines)
+packages/runtime/core/
+  ├── package.json                               (new package)
+  ├── tsconfig.json
+  ├── jest.config.js
+  ├── README.md
+  ├── ARCHITECTURE.md
+  ├── src/
+  │   ├── index.ts
+  │   ├── plugin-manager.ts                      (202 lines)
+  │   ├── query-pipeline.ts                      (175 lines)
+  │   └── runtime.ts                             (103 lines)
+  └── test/
+      ├── plugin-manager.test.ts                 (346 lines)
+      ├── query-pipeline.test.ts                 (374 lines)
+      ├── runtime.test.ts                        (261 lines)
+      └── demo.ts                                (139 lines)
+
+Total: 13 files, 1,658+ lines
+```
+
+## Verification
+
+✅ All tests passing (39/39)
+✅ TypeScript compilation successful
+✅ Build output generated (dist/)
+✅ Demo script runs successfully
+✅ No circular dependencies
+✅ Repository-level build succeeds
+
+## Usage Example
+
+```typescript
+import { createRuntime } from '@objectql/runtime-core';
+import type { QueryProcessorPlugin } from '@objectql/types';
+
+const securityPlugin: QueryProcessorPlugin = {
+  metadata: {
+    name: 'security',
+    type: 'query_processor'
+  },
+  async beforeQuery(query, context) {
+    // Add tenant filter automatically
+    return {
+      ...query,
+      filters: [
+        ...(query.filters || []),
+        ['tenant_id', '=', context.user?.tenant_id]
+      ]
+    };
+  }
+};
+
+const runtime = createRuntime({ plugins: [securityPlugin] });
+runtime.setQueryExecutor(yourDriver.execute);
+await runtime.init();
+
+const results = await runtime.query('project', {
+  filters: [['status', '=', 'active']]
+}, { user: { tenant_id: 'tenant-1' } });
+```
+
+## Conclusion
+
+This implementation successfully delivers:
+1. ✅ Production-ready plugin system with dependency management
+2. ✅ Query processing pipeline with waterfall pattern
+3. ✅ Clean separation between protocol and implementation
+4. ✅ Comprehensive test coverage
+5. ✅ Clear documentation and examples
+
+The runtime core is now ready for integration into the ObjectQL ecosystem.
diff --git a/packages/runtime/core/README.md b/packages/runtime/core/README.md
new file mode 100644
index 00000000..55e05667
--- /dev/null
+++ b/packages/runtime/core/README.md
@@ -0,0 +1,51 @@
+# @objectql/runtime-core
+
+Runtime core package for ObjectQL - Plugin system, query pipeline, and runtime orchestration.
+
+## Features
+
+- **PluginManager**: Dependency resolution and plugin lifecycle management
+- **QueryPipeline**: Async series waterfall query processing
+- **Runtime Factory**: `createRuntime()` for runtime initialization
+
+## Installation
+
+```bash
+npm install @objectql/runtime-core @objectql/types
+```
+
+## Usage
+
+```typescript
+import { createRuntime } from '@objectql/runtime-core';
+import { BasePlugin } from '@objectql/types';
+
+// Define a plugin
+const myPlugin: BasePlugin = {
+  metadata: {
+    name: 'my-plugin',
+    version: '1.0.0',
+    dependencies: []
+  },
+  async setup(runtime) {
+    console.log('Plugin initialized');
+  }
+};
+
+// Create runtime instance
+const runtime = createRuntime({
+  plugins: [myPlugin]
+});
+
+// Initialize
+await runtime.init();
+
+// Execute queries
+const results = await runtime.query('project', {
+  filters: [['status', '=', 'active']]
+});
+```
+
+## License
+
+MIT
diff --git a/packages/runtime/core/jest.config.js b/packages/runtime/core/jest.config.js
new file mode 100644
index 00000000..58e97edf
--- /dev/null
+++ b/packages/runtime/core/jest.config.js
@@ -0,0 +1,7 @@
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  roots: ['<rootDir>/test'],
+  testMatch: ['**/*.test.ts'],
+  collectCoverageFrom: ['src/**/*.ts'],
+};
diff --git a/packages/runtime/core/package.json b/packages/runtime/core/package.json
new file mode 100644
index 00000000..dc6c4a00
--- /dev/null
+++ b/packages/runtime/core/package.json
@@ -0,0 +1,28 @@
+{
+  "name": "@objectql/runtime-core",
+  "version": "3.0.1",
+  "description": "ObjectQL runtime core - Plugin system, query pipeline, and runtime orchestration",
+  "keywords": [
+    "objectql",
+    "runtime",
+    "plugin",
+    "pipeline",
+    "query-processor",
+    "dependency-injection",
+    "orchestration"
+  ],
+  "license": "MIT",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "test": "jest"
+  },
+  "dependencies": {
+    "@objectql/types": "workspace:*"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "typescript": "^5.3.0"
+  }
+}
diff --git a/packages/runtime/core/src/index.ts b/packages/runtime/core/src/index.ts
new file mode 100644
index 00000000..5e1b1a4c
--- /dev/null
+++ b/packages/runtime/core/src/index.ts
@@ -0,0 +1,17 @@
+/**
+ * ObjectQL
+ * Copyright (c) 2026-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+// Export main runtime factory
+export { createRuntime } from './runtime';
+export type { Runtime, RuntimeConfig, QueryExecutor } from './runtime';
+
+// Export PluginManager
+export { PluginManager, PluginError } from './plugin-manager';
+
+// Export QueryPipeline
+export { QueryPipeline, PipelineError } from './query-pipeline';
diff --git a/packages/runtime/core/src/plugin-manager.ts b/packages/runtime/core/src/plugin-manager.ts
new file mode 100644
index 00000000..87c1d160
--- /dev/null
+++ b/packages/runtime/core/src/plugin-manager.ts
@@ -0,0 +1,202 @@
+/**
+ * ObjectQL
+ * Copyright (c) 2026-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import { BasePlugin } from '@objectql/types';
+
+/**
+ * Error thrown when plugin operations fail
+ */
+export class PluginError extends Error {
+    constructor(
+        public code: 'DUPLICATE_PLUGIN' | 'MISSING_DEPENDENCY' | 'CIRCULAR_DEPENDENCY' | 'SETUP_FAILED',
+        message: string,
+        public pluginName?: string
+    ) {
+        super(message);
+        this.name = 'PluginError';
+    }
+}
+
+/**
+ * PluginManager handles plugin registration, dependency resolution, and lifecycle
+ */
+export class PluginManager {
+    private plugins: Map<string, BasePlugin> = new Map();
+    private setupOrder: string[] = [];
+    private isBooted = false;
+
+    /**
+     * Register a plugin
+     * @param plugin Plugin to register
+     * @throws {PluginError} If plugin name is duplicated
+     */
+    register(plugin: BasePlugin): void {
+        const name = plugin.metadata.name;
+        
+        if (this.plugins.has(name)) {
+            throw new PluginError(
+                'DUPLICATE_PLUGIN',
+                `Plugin "${name}" is already registered`,
+                name
+            );
+        }
+
+        this.plugins.set(name, plugin);
+        this.setupOrder = []; // Invalidate cached order
+    }
+
+    /**
+     * Resolve plugin dependencies using topological sort
+     * @returns Ordered list of plugin names (dependencies first)
+     * @throws {PluginError} If there are missing dependencies or circular dependencies
+     */
+    resolveDependencies(): string[] {
+        if (this.setupOrder.length > 0) {
+            return this.setupOrder;
+        }
+
+        const visited = new Set<string>();
+        const visiting = new Set<string>();
+        const order: string[] = [];
+
+        const visit = (pluginName: string, path: string[] = []): void => {
+            // Check if already processed
+            if (visited.has(pluginName)) {
+                return;
+            }
+
+            // Check for circular dependency
+            if (visiting.has(pluginName)) {
+                const cycle = [...path, pluginName].join(' -> ');
+                throw new PluginError(
+                    'CIRCULAR_DEPENDENCY',
+                    `Circular dependency detected: ${cycle}`,
+                    pluginName
+                );
+            }
+
+            const plugin = this.plugins.get(pluginName);
+            if (!plugin) {
+                throw new PluginError(
+                    'MISSING_DEPENDENCY',
+                    `Plugin "${pluginName}" is required but not registered`,
+                    pluginName
+                );
+            }
+
+            // Mark as being visited
+            visiting.add(pluginName);
+
+            // Visit dependencies first
+            const dependencies = plugin.metadata.dependencies || [];
+            for (const dep of dependencies) {
+                visit(dep, [...path, pluginName]);
+            }
+
+            // Mark as visited and add to order
+            visiting.delete(pluginName);
+            visited.add(pluginName);
+            order.push(pluginName);
+        };
+
+        // Visit all plugins
+        for (const pluginName of this.plugins.keys()) {
+            visit(pluginName);
+        }
+
+        this.setupOrder = order;
+        return order;
+    }
+
+    /**
+     * Boot all plugins in dependency order
+     * @param runtime Runtime instance to pass to setup hooks
+     * @throws {PluginError} If setup fails for any plugin
+     */
+    async boot(runtime: any): Promise<void> {
+        if (this.isBooted) {
+            return;
+        }
+
+        const order = this.resolveDependencies();
+
+        for (const pluginName of order) {
+            const plugin = this.plugins.get(pluginName);
+            if (!plugin) {
+                continue; // Should never happen after resolveDependencies
+            }
+
+            if (plugin.setup) {
+                try {
+                    await plugin.setup(runtime);
+                } catch (error) {
+                    throw new PluginError(
+                        'SETUP_FAILED',
+                        `Failed to setup plugin "${pluginName}": ${error instanceof Error ? error.message : String(error)}`,
+                        pluginName
+                    );
+                }
+            }
+        }
+
+        this.isBooted = true;
+    }
+
+    /**
+     * Shutdown all plugins in reverse dependency order
+     */
+    async shutdown(): Promise<void> {
+        if (!this.isBooted) {
+            return;
+        }
+
+        const order = [...this.setupOrder].reverse();
+
+        for (const pluginName of order) {
+            const plugin = this.plugins.get(pluginName);
+            if (plugin?.teardown) {
+                try {
+                    await plugin.teardown();
+                } catch (error) {
+                    // Log but don't throw during shutdown
+                    console.error(`Failed to teardown plugin "${pluginName}":`, error);
+                }
+            }
+        }
+
+        this.isBooted = false;
+    }
+
+    /**
+     * Get a registered plugin by name
+     */
+    get(name: string): BasePlugin | undefined {
+        return this.plugins.get(name);
+    }
+
+    /**
+     * Get all registered plugins
+     */
+    getAll(): BasePlugin[] {
+        return Array.from(this.plugins.values());
+    }
+
+    /**
+     * Get plugins by type
+     */
+    getByType(type: string): BasePlugin[] {
+        return this.getAll().filter(p => p.metadata.type === type);
+    }
+
+    /**
+     * Check if booted
+     */
+    isInitialized(): boolean {
+        return this.isBooted;
+    }
+}
diff --git a/packages/runtime/core/src/query-pipeline.ts b/packages/runtime/core/src/query-pipeline.ts
new file mode 100644
index 00000000..c9b7e268
--- /dev/null
+++ b/packages/runtime/core/src/query-pipeline.ts
@@ -0,0 +1,175 @@
+/**
+ * ObjectQL
+ * Copyright (c) 2026-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import { UnifiedQuery, QueryProcessorPlugin, QueryProcessorContext } from '@objectql/types';
+import { PluginManager } from './plugin-manager';
+
+/**
+ * Error thrown when query pipeline operations fail
+ */
+export class PipelineError extends Error {
+    constructor(
+        public code: 'VALIDATION_FAILED' | 'EXECUTION_FAILED',
+        message: string,
+        public pluginName?: string
+    ) {
+        super(message);
+        this.name = 'PipelineError';
+    }
+}
+
+/**
+ * QueryPipeline manages query processing through registered plugins
+ * using async series waterfall pattern
+ */
+export class QueryPipeline {
+    constructor(private pluginManager: PluginManager) {}
+
+    /**
+     * Execute a query through the pipeline
+     * @param objectName The object to query
+     * @param query The query to execute
+     * @param context Query execution context
+     * @param executor Function to execute the query (driver)
+     * @returns Query results
+     */
+    async execute(
+        objectName: string,
+        query: UnifiedQuery,
+        context: QueryProcessorContext,
+        executor: (objectName: string, query: UnifiedQuery) => Promise<any[]>
+    ): Promise<any[]> {
+        const processors = this.getQueryProcessors();
+
+        // Prepare context
+        const fullContext: QueryProcessorContext = {
+            ...context,
+            objectName
+        };
+
+        // Phase 1: Validation
+        await this.runValidation(processors, query, fullContext);
+
+        // Phase 2: beforeQuery (waterfall transformation)
+        const transformedQuery = await this.runBeforeQuery(processors, query, fullContext);
+
+        // Phase 3: Execute query
+        let results: any[];
+        try {
+            results = await executor(objectName, transformedQuery);
+        } catch (error) {
+            throw new PipelineError(
+                'EXECUTION_FAILED',
+                `Query execution failed: ${error instanceof Error ? error.message : String(error)}`
+            );
+        }
+
+        // Phase 4: afterQuery (waterfall transformation)
+        const transformedResults = await this.runAfterQuery(processors, results, fullContext);
+
+        return transformedResults;
+    }
+
+    /**
+     * Get all registered query processor plugins
+     */
+    private getQueryProcessors(): QueryProcessorPlugin[] {
+        return this.pluginManager
+            .getByType('query_processor')
+            .filter((p): p is QueryProcessorPlugin => {
+                return p.metadata.type === 'query_processor';
+            });
+    }
+
+    /**
+     * Run validation phase
+     */
+    private async runValidation(
+        processors: QueryProcessorPlugin[],
+        query: UnifiedQuery,
+        context: QueryProcessorContext
+    ): Promise<void> {
+        for (const processor of processors) {
+            if (processor.validateQuery) {
+                try {
+                    await processor.validateQuery(query, context);
+                } catch (error) {
+                    throw new PipelineError(
+                        'VALIDATION_FAILED',
+                        `Query validation failed in plugin "${processor.metadata.name}": ${
+                            error instanceof Error ? error.message : String(error)
+                        }`,
+                        processor.metadata.name
+                    );
+                }
+            }
+        }
+    }
+
+    /**
+     * Run beforeQuery phase (async series waterfall)
+     * Each plugin receives the output of the previous plugin
+     */
+    private async runBeforeQuery(
+        processors: QueryProcessorPlugin[],
+        initialQuery: UnifiedQuery,
+        context: QueryProcessorContext
+    ): Promise<UnifiedQuery> {
+        let currentQuery = initialQuery;
+
+        for (const processor of processors) {
+            if (processor.beforeQuery) {
+                try {
+                    const result = await processor.beforeQuery(currentQuery, context);
+                    currentQuery = result || currentQuery;
+                } catch (error) {
+                    throw new PipelineError(
+                        'EXECUTION_FAILED',
+                        `beforeQuery failed in plugin "${processor.metadata.name}": ${
+                            error instanceof Error ? error.message : String(error)
+                        }`,
+                        processor.metadata.name
+                    );
+                }
+            }
+        }
+
+        return currentQuery;
+    }
+
+    /**
+     * Run afterQuery phase (async series waterfall)
+     * Each plugin receives the output of the previous plugin
+     */
+    private async runAfterQuery(
+        processors: QueryProcessorPlugin[],
+        initialResults: any[],
+        context: QueryProcessorContext
+    ): Promise<any[]> {
+        let currentResults = initialResults;
+
+        for (const processor of processors) {
+            if (processor.afterQuery) {
+                try {
+                    const result = await processor.afterQuery(currentResults, context);
+                    currentResults = result || currentResults;
+                } catch (error) {
+                    throw new PipelineError(
+                        'EXECUTION_FAILED',
+                        `afterQuery failed in plugin "${processor.metadata.name}": ${
+                            error instanceof Error ? error.message : String(error)
+                        }`,
+                        processor.metadata.name
+                    );
+                }
+            }
+        }
+
+        return currentResults;
+    }
+}
diff --git a/packages/runtime/core/src/runtime.ts b/packages/runtime/core/src/runtime.ts
new file mode 100644
index 00000000..3cd88514
--- /dev/null
+++ b/packages/runtime/core/src/runtime.ts
@@ -0,0 +1,103 @@
+/**
+ * ObjectQL
+ * Copyright (c) 2026-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import { BasePlugin, UnifiedQuery, QueryProcessorContext } from '@objectql/types';
+import { PluginManager } from './plugin-manager';
+import { QueryPipeline } from './query-pipeline';
+
+/**
+ * Runtime configuration
+ */
+export interface RuntimeConfig {
+    /** Plugins to register */
+    plugins?: BasePlugin[];
+}
+
+/**
+ * Query executor function (provided by driver or higher level)
+ */
+export type QueryExecutor = (objectName: string, query: UnifiedQuery) => Promise<any[]>;
+
+/**
+ * Runtime instance
+ */
+export interface Runtime {
+    /** Plugin manager */
+    pluginManager: PluginManager;
+    
+    /** Initialize the runtime */
+    init(): Promise<void>;
+    
+    /** Execute a query through the pipeline */
+    query(objectName: string, query: UnifiedQuery, context?: Partial<QueryProcessorContext>): Promise<any[]>;
+    
+    /** Shutdown the runtime */
+    shutdown(): Promise<void>;
+    
+    /** Set the query executor (driver) */
+    setQueryExecutor(executor: QueryExecutor): void;
+}
+
+/**
+ * Internal runtime implementation
+ */
+class RuntimeImpl implements Runtime {
+    public pluginManager: PluginManager;
+    private pipeline: QueryPipeline;
+    private queryExecutor?: QueryExecutor;
+
+    constructor(config: RuntimeConfig) {
+        this.pluginManager = new PluginManager();
+        this.pipeline = new QueryPipeline(this.pluginManager);
+
+        // Register plugins
+        if (config.plugins) {
+            for (const plugin of config.plugins) {
+                this.pluginManager.register(plugin);
+            }
+        }
+    }
+
+    async init(): Promise<void> {
+        await this.pluginManager.boot(this);
+    }
+
+    async query(
+        objectName: string,
+        query: UnifiedQuery,
+        context: Partial<QueryProcessorContext> = {}
+    ): Promise<any[]> {
+        if (!this.queryExecutor) {
+            throw new Error('Query executor not set. Call setQueryExecutor() first.');
+        }
+
+        return this.pipeline.execute(
+            objectName,
+            query,
+            context as QueryProcessorContext,
+            this.queryExecutor
+        );
+    }
+
+    async shutdown(): Promise<void> {
+        await this.pluginManager.shutdown();
+    }
+
+    setQueryExecutor(executor: QueryExecutor): void {
+        this.queryExecutor = executor;
+    }
+}
+
+/**
+ * Create a runtime instance
+ * @param config Runtime configuration
+ * @returns Runtime instance
+ */
+export function createRuntime(config: RuntimeConfig = {}): Runtime {
+    return new RuntimeImpl(config);
+}
diff --git a/packages/runtime/core/test/demo.ts b/packages/runtime/core/test/demo.ts
new file mode 100644
index 00000000..21d788a1
--- /dev/null
+++ b/packages/runtime/core/test/demo.ts
@@ -0,0 +1,118 @@
+/**
+ * ObjectQL Runtime Core - Example Usage
+ * 
+ * This example demonstrates the key features:
+ * 1. Plugin dependency resolution
+ * 2. Query pipeline with waterfall processing
+ * 3. Runtime lifecycle management
+ */
+
+import { createRuntime } from '../src/index';
+import type { BasePlugin, QueryProcessorPlugin } from '@objectql/types';
+
+// Example 1: Basic plugin with dependencies
+const loggerPlugin: BasePlugin = {
+    metadata: {
+        name: 'logger',
+        version: '1.0.0',
+        type: 'extension'
+    },
+    async setup(runtime) {
+        console.log('[Logger] Plugin initialized');
+    }
+};
+
+const cachePlugin: BasePlugin = {
+    metadata: {
+        name: 'cache',
+        version: '1.0.0',
+        type: 'extension',
+        dependencies: ['logger'] // Depends on logger
+    },
+    async setup(runtime) {
+        console.log('[Cache] Plugin initialized (after logger)');
+    }
+};
+
+// Example 2: Query processor plugin
+const securityPlugin: QueryProcessorPlugin = {
+    metadata: {
+        name: 'security',
+        version: '1.0.0',
+        type: 'query_processor',
+        dependencies: ['logger']
+    },
+    async setup(runtime) {
+        console.log('[Security] Plugin initialized');
+    },
+    async validateQuery(query, context) {
+        // Validate user has permission
+        if (!context.user) {
+            throw new Error('Authentication required');
+        }
+    },
+    async beforeQuery(query, context) {
+        console.log(`[Security] User ${context.user?.id} executing query`);
+        // Add tenant filter automatically
+        return {
+            ...query,
+            filters: [
+                ...(query.filters || []),
+                ['tenant_id', '=', context.user?.tenant_id]
+            ]
+        };
+    }
+};
+
+// Example 3: Demo runtime usage
+async function demo() {
+    console.log('=== ObjectQL Runtime Core Demo ===\n');
+
+    // Create runtime with plugins
+    const runtime = createRuntime({
+        plugins: [
+            securityPlugin, // Registered in any order
+            cachePlugin,
+            loggerPlugin
+        ]
+    });
+
+    // Set query executor (mock)
+    runtime.setQueryExecutor(async (objectName, query) => {
+        console.log(`[Driver] Executing query on ${objectName}:`, query);
+        return [
+            { id: 1, name: 'Project 1', tenant_id: 'tenant-1' }
+        ];
+    });
+
+    // Initialize (plugins will be setup in dependency order)
+    console.log('\n1. Initializing runtime...');
+    await runtime.init();
+
+    // Execute query through pipeline
+    console.log('\n2. Executing query through pipeline...');
+    const results = await runtime.query('project', {
+        fields: ['id', 'name'],
+        filters: [['status', '=', 'active']]
+    }, {
+        user: {
+            id: 'user-123',
+            tenant_id: 'tenant-1'
+        }
+    });
+
+    console.log('\n3. Results:', results);
+
+    // Shutdown
+    console.log('\n4. Shutting down runtime...');
+    await runtime.shutdown();
+
+    console.log('\n=== Demo Complete ===');
+}
+
+// Run demo if this file is executed directly
+if (require.main === module) {
+    demo().catch(console.error);
+}
+
+export { demo };
diff --git a/packages/runtime/core/test/plugin-manager.test.ts b/packages/runtime/core/test/plugin-manager.test.ts
new file mode 100644
index 00000000..94b44f12
--- /dev/null
+++ b/packages/runtime/core/test/plugin-manager.test.ts
@@ -0,0 +1,346 @@
+/**
+ * ObjectQL
+ * Copyright (c) 2026-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import { PluginManager, PluginError } from '../src/plugin-manager';
+import { BasePlugin } from '@objectql/types';
+
+describe('PluginManager', () => {
+    let manager: PluginManager;
+
+    beforeEach(() => {
+        manager = new PluginManager();
+    });
+
+    describe('plugin registration', () => {
+        it('should register a plugin successfully', () => {
+            const plugin: BasePlugin = {
+                metadata: { name: 'test-plugin', version: '1.0.0' }
+            };
+
+            manager.register(plugin);
+            expect(manager.get('test-plugin')).toBe(plugin);
+        });
+
+        it('should throw error for duplicate plugin names', () => {
+            const plugin1: BasePlugin = {
+                metadata: { name: 'duplicate', version: '1.0.0' }
+            };
+            const plugin2: BasePlugin = {
+                metadata: { name: 'duplicate', version: '2.0.0' }
+            };
+
+            manager.register(plugin1);
+            expect(() => manager.register(plugin2)).toThrow(PluginError);
+            expect(() => manager.register(plugin2)).toThrow('already registered');
+        });
+    });
+
+    describe('dependency resolution', () => {
+        it('should resolve plugins with no dependencies', () => {
+            const pluginA: BasePlugin = {
+                metadata: { name: 'plugin-a' }
+            };
+            const pluginB: BasePlugin = {
+                metadata: { name: 'plugin-b' }
+            };
+
+            manager.register(pluginA);
+            manager.register(pluginB);
+
+            const order = manager.resolveDependencies();
+            expect(order).toHaveLength(2);
+            expect(order).toContain('plugin-a');
+            expect(order).toContain('plugin-b');
+        });
+
+        it('should resolve plugins with simple dependencies', () => {
+            const pluginA: BasePlugin = {
+                metadata: { name: 'plugin-a', dependencies: [] }
+            };
+            const pluginB: BasePlugin = {
+                metadata: { name: 'plugin-b', dependencies: ['plugin-a'] }
+            };
+
+            manager.register(pluginA);
+            manager.register(pluginB);
+
+            const order = manager.resolveDependencies();
+            expect(order).toEqual(['plugin-a', 'plugin-b']);
+        });
+
+        it('should resolve complex dependency chains', () => {
+            // Setup: D depends on C, C depends on B, B depends on A
+            const pluginA: BasePlugin = {
+                metadata: { name: 'a', dependencies: [] }
+            };
+            const pluginB: BasePlugin = {
+                metadata: { name: 'b', dependencies: ['a'] }
+            };
+            const pluginC: BasePlugin = {
+                metadata: { name: 'c', dependencies: ['b'] }
+            };
+            const pluginD: BasePlugin = {
+                metadata: { name: 'd', dependencies: ['c'] }
+            };
+
+            // Register in random order
+            manager.register(pluginD);
+            manager.register(pluginB);
+            manager.register(pluginA);
+            manager.register(pluginC);
+
+            const order = manager.resolveDependencies();
+            expect(order).toEqual(['a', 'b', 'c', 'd']);
+        });
+
+        it('should resolve diamond dependencies correctly', () => {
+            // Setup: D depends on B and C, both B and C depend on A
+            const pluginA: BasePlugin = {
+                metadata: { name: 'a', dependencies: [] }
+            };
+            const pluginB: BasePlugin = {
+                metadata: { name: 'b', dependencies: ['a'] }
+            };
+            const pluginC: BasePlugin = {
+                metadata: { name: 'c', dependencies: ['a'] }
+            };
+            const pluginD: BasePlugin = {
+                metadata: { name: 'd', dependencies: ['b', 'c'] }
+            };
+
+            manager.register(pluginA);
+            manager.register(pluginB);
+            manager.register(pluginC);
+            manager.register(pluginD);
+
+            const order = manager.resolveDependencies();
+            
+            // A must come first
+            expect(order[0]).toBe('a');
+            // D must come last
+            expect(order[3]).toBe('d');
+            // B and C must come after A and before D
+            expect(order.indexOf('b')).toBeGreaterThan(order.indexOf('a'));
+            expect(order.indexOf('c')).toBeGreaterThan(order.indexOf('a'));
+            expect(order.indexOf('d')).toBeGreaterThan(order.indexOf('b'));
+            expect(order.indexOf('d')).toBeGreaterThan(order.indexOf('c'));
+        });
+
+        it('should throw error for missing dependencies', () => {
+            const pluginB: BasePlugin = {
+                metadata: { name: 'b', dependencies: ['a'] }
+            };
+
+            manager.register(pluginB);
+
+            expect(() => manager.resolveDependencies()).toThrow(PluginError);
+            expect(() => manager.resolveDependencies()).toThrow('not registered');
+        });
+
+        it('should detect circular dependencies', () => {
+            const pluginA: BasePlugin = {
+                metadata: { name: 'a', dependencies: ['b'] }
+            };
+            const pluginB: BasePlugin = {
+                metadata: { name: 'b', dependencies: ['a'] }
+            };
+
+            manager.register(pluginA);
+            manager.register(pluginB);
+
+            expect(() => manager.resolveDependencies()).toThrow(PluginError);
+            expect(() => manager.resolveDependencies()).toThrow('Circular dependency');
+        });
+
+        it('should detect complex circular dependencies', () => {
+            const pluginA: BasePlugin = {
+                metadata: { name: 'a', dependencies: ['c'] }
+            };
+            const pluginB: BasePlugin = {
+                metadata: { name: 'b', dependencies: ['a'] }
+            };
+            const pluginC: BasePlugin = {
+                metadata: { name: 'c', dependencies: ['b'] }
+            };
+
+            manager.register(pluginA);
+            manager.register(pluginB);
+            manager.register(pluginC);
+
+            expect(() => manager.resolveDependencies()).toThrow(PluginError);
+            expect(() => manager.resolveDependencies()).toThrow('Circular dependency');
+        });
+    });
+
+    describe('plugin boot lifecycle', () => {
+        it('should call setup in dependency order', async () => {
+            const setupOrder: string[] = [];
+
+            const pluginA: BasePlugin = {
+                metadata: { name: 'a' },
+                async setup() {
+                    setupOrder.push('a');
+                }
+            };
+            const pluginB: BasePlugin = {
+                metadata: { name: 'b', dependencies: ['a'] },
+                async setup() {
+                    setupOrder.push('b');
+                }
+            };
+
+            manager.register(pluginA);
+            manager.register(pluginB);
+
+            await manager.boot({});
+
+            expect(setupOrder).toEqual(['a', 'b']);
+            expect(manager.isInitialized()).toBe(true);
+        });
+
+        it('should pass runtime to setup hooks', async () => {
+            let receivedRuntime: any;
+
+            const plugin: BasePlugin = {
+                metadata: { name: 'test' },
+                async setup(runtime) {
+                    receivedRuntime = runtime;
+                }
+            };
+
+            manager.register(plugin);
+
+            const mockRuntime = { id: 'test-runtime' };
+            await manager.boot(mockRuntime);
+
+            expect(receivedRuntime).toBe(mockRuntime);
+        });
+
+        it('should throw error if setup fails', async () => {
+            const plugin: BasePlugin = {
+                metadata: { name: 'failing-plugin' },
+                async setup() {
+                    throw new Error('Setup failed');
+                }
+            };
+
+            manager.register(plugin);
+
+            await expect(manager.boot({})).rejects.toThrow(PluginError);
+            await expect(manager.boot({})).rejects.toThrow('Failed to setup');
+        });
+
+        it('should not boot twice', async () => {
+            const setupCalls = { count: 0 };
+
+            const plugin: BasePlugin = {
+                metadata: { name: 'test' },
+                async setup() {
+                    setupCalls.count++;
+                }
+            };
+
+            manager.register(plugin);
+
+            await manager.boot({});
+            await manager.boot({});
+
+            expect(setupCalls.count).toBe(1);
+        });
+    });
+
+    describe('plugin shutdown', () => {
+        it('should call teardown in reverse order', async () => {
+            const teardownOrder: string[] = [];
+
+            const pluginA: BasePlugin = {
+                metadata: { name: 'a' },
+                async setup() {},
+                async teardown() {
+                    teardownOrder.push('a');
+                }
+            };
+            const pluginB: BasePlugin = {
+                metadata: { name: 'b', dependencies: ['a'] },
+                async setup() {},
+                async teardown() {
+                    teardownOrder.push('b');
+                }
+            };
+
+            manager.register(pluginA);
+            manager.register(pluginB);
+
+            await manager.boot({});
+            await manager.shutdown();
+
+            expect(teardownOrder).toEqual(['b', 'a']);
+            expect(manager.isInitialized()).toBe(false);
+        });
+
+        it('should handle teardown errors gracefully', async () => {
+            const consoleError = jest.spyOn(console, 'error').mockImplementation();
+
+            const plugin: BasePlugin = {
+                metadata: { name: 'failing' },
+                async setup() {},
+                async teardown() {
+                    throw new Error('Teardown failed');
+                }
+            };
+
+            manager.register(plugin);
+            await manager.boot({});
+
+            await expect(manager.shutdown()).resolves.not.toThrow();
+            expect(consoleError).toHaveBeenCalled();
+
+            consoleError.mockRestore();
+        });
+    });
+
+    describe('plugin queries', () => {
+        it('should get all plugins', () => {
+            const pluginA: BasePlugin = {
+                metadata: { name: 'a', type: 'driver' }
+            };
+            const pluginB: BasePlugin = {
+                metadata: { name: 'b', type: 'extension' }
+            };
+
+            manager.register(pluginA);
+            manager.register(pluginB);
+
+            const all = manager.getAll();
+            expect(all).toHaveLength(2);
+            expect(all).toContainEqual(pluginA);
+            expect(all).toContainEqual(pluginB);
+        });
+
+        it('should get plugins by type', () => {
+            const pluginA: BasePlugin = {
+                metadata: { name: 'a', type: 'driver' }
+            };
+            const pluginB: BasePlugin = {
+                metadata: { name: 'b', type: 'query_processor' }
+            };
+            const pluginC: BasePlugin = {
+                metadata: { name: 'c', type: 'query_processor' }
+            };
+
+            manager.register(pluginA);
+            manager.register(pluginB);
+            manager.register(pluginC);
+
+            const processors = manager.getByType('query_processor');
+            expect(processors).toHaveLength(2);
+            expect(processors.map(p => p.metadata.name)).toContain('b');
+            expect(processors.map(p => p.metadata.name)).toContain('c');
+        });
+    });
+});
diff --git a/packages/runtime/core/test/query-pipeline.test.ts b/packages/runtime/core/test/query-pipeline.test.ts
new file mode 100644
index 00000000..ea208024
--- /dev/null
+++ b/packages/runtime/core/test/query-pipeline.test.ts
@@ -0,0 +1,374 @@
+/**
+ * ObjectQL
+ * Copyright (c) 2026-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import { QueryPipeline, PipelineError } from '../src/query-pipeline';
+import { PluginManager } from '../src/plugin-manager';
+import { QueryProcessorPlugin, UnifiedQuery, QueryProcessorContext } from '@objectql/types';
+
+describe('QueryPipeline', () => {
+    let manager: PluginManager;
+    let pipeline: QueryPipeline;
+
+    beforeEach(() => {
+        manager = new PluginManager();
+        pipeline = new QueryPipeline(manager);
+    });
+
+    describe('basic execution', () => {
+        it('should execute query without any processors', async () => {
+            const mockExecutor = jest.fn().mockResolvedValue([
+                { id: 1, name: 'Test' }
+            ]);
+
+            const results = await pipeline.execute(
+                'project',
+                { filters: [['status', '=', 'active']] },
+                { objectName: 'project' },
+                mockExecutor
+            );
+
+            expect(results).toEqual([{ id: 1, name: 'Test' }]);
+            expect(mockExecutor).toHaveBeenCalledWith('project', {
+                filters: [['status', '=', 'active']]
+            });
+        });
+
+        it('should throw error if executor fails', async () => {
+            const mockExecutor = jest.fn().mockRejectedValue(new Error('DB error'));
+
+            await expect(
+                pipeline.execute(
+                    'project',
+                    {},
+                    { objectName: 'project' },
+                    mockExecutor
+                )
+            ).rejects.toThrow(PipelineError);
+        });
+    });
+
+    describe('validation phase', () => {
+        it('should run validation before execution', async () => {
+            const validationCalls: string[] = [];
+
+            const plugin: QueryProcessorPlugin = {
+                metadata: {
+                    name: 'validator',
+                    type: 'query_processor'
+                },
+                async validateQuery(query, context) {
+                    validationCalls.push('validated');
+                    if (!query.filters || query.filters.length === 0) {
+                        throw new Error('Filters required');
+                    }
+                }
+            };
+
+            manager.register(plugin);
+
+            const mockExecutor = jest.fn().mockResolvedValue([]);
+
+            // Should pass validation
+            await pipeline.execute('project', { filters: [['id', '=', 1]] }, {
+                objectName: 'project'
+            }, mockExecutor);
+
+            expect(validationCalls).toHaveLength(1);
+
+            // Should fail validation
+            await expect(
+                pipeline.execute('project', {}, { objectName: 'project' }, mockExecutor)
+            ).rejects.toThrow(PipelineError);
+        });
+
+        it('should run all validators', async () => {
+            const validations: string[] = [];
+
+            const plugin1: QueryProcessorPlugin = {
+                metadata: { name: 'v1', type: 'query_processor' },
+                async validateQuery() {
+                    validations.push('v1');
+                }
+            };
+
+            const plugin2: QueryProcessorPlugin = {
+                metadata: { name: 'v2', type: 'query_processor' },
+                async validateQuery() {
+                    validations.push('v2');
+                }
+            };
+
+            manager.register(plugin1);
+            manager.register(plugin2);
+
+            await pipeline.execute('project', {}, { objectName: 'project' }, async () => []);
+
+            expect(validations).toEqual(['v1', 'v2']);
+        });
+    });
+
+    describe('beforeQuery phase (waterfall)', () => {
+        it('should transform query through waterfall', async () => {
+            const plugin1: QueryProcessorPlugin = {
+                metadata: { name: 'p1', type: 'query_processor' },
+                async beforeQuery(query) {
+                    return {
+                        ...query,
+                        fields: ['id', 'name']
+                    };
+                }
+            };
+
+            const plugin2: QueryProcessorPlugin = {
+                metadata: { name: 'p2', type: 'query_processor' },
+                async beforeQuery(query) {
+                    return {
+                        ...query,
+                        limit: 10
+                    };
+                }
+            };
+
+            manager.register(plugin1);
+            manager.register(plugin2);
+
+            const mockExecutor = jest.fn().mockResolvedValue([]);
+
+            await pipeline.execute('project', {}, { objectName: 'project' }, mockExecutor);
+
+            expect(mockExecutor).toHaveBeenCalledWith('project', {
+                fields: ['id', 'name'],
+                limit: 10
+            });
+        });
+
+        it('should pass transformed query from one plugin to next', async () => {
+            let receivedQuery: UnifiedQuery | null = null;
+
+            const plugin1: QueryProcessorPlugin = {
+                metadata: { name: 'p1', type: 'query_processor' },
+                async beforeQuery(query) {
+                    return {
+                        ...query,
+                        modified: 'by-p1'
+                    } as any;
+                }
+            };
+
+            const plugin2: QueryProcessorPlugin = {
+                metadata: { name: 'p2', type: 'query_processor' },
+                async beforeQuery(query) {
+                    receivedQuery = query;
+                    return query;
+                }
+            };
+
+            manager.register(plugin1);
+            manager.register(plugin2);
+
+            await pipeline.execute('project', {}, { objectName: 'project' }, async () => []);
+
+            expect(receivedQuery).toEqual({ modified: 'by-p1' });
+        });
+    });
+
+    describe('afterQuery phase (waterfall)', () => {
+        it('should transform results through waterfall', async () => {
+            const plugin1: QueryProcessorPlugin = {
+                metadata: { name: 'p1', type: 'query_processor' },
+                async afterQuery(results) {
+                    return results.map(r => ({ ...r, decorated: true }));
+                }
+            };
+
+            const plugin2: QueryProcessorPlugin = {
+                metadata: { name: 'p2', type: 'query_processor' },
+                async afterQuery(results) {
+                    return results.filter(r => (r as any).decorated);
+                }
+            };
+
+            manager.register(plugin1);
+            manager.register(plugin2);
+
+            const mockExecutor = jest.fn().mockResolvedValue([
+                { id: 1 },
+                { id: 2 }
+            ]);
+
+            const results = await pipeline.execute(
+                'project',
+                {},
+                { objectName: 'project' },
+                mockExecutor
+            );
+
+            expect(results).toEqual([
+                { id: 1, decorated: true },
+                { id: 2, decorated: true }
+            ]);
+        });
+
+        it('should pass transformed results from one plugin to next', async () => {
+            let receivedResults: any[] | null = null;
+
+            const plugin1: QueryProcessorPlugin = {
+                metadata: { name: 'p1', type: 'query_processor' },
+                async afterQuery(results) {
+                    return [{ modified: 'by-p1' }];
+                }
+            };
+
+            const plugin2: QueryProcessorPlugin = {
+                metadata: { name: 'p2', type: 'query_processor' },
+                async afterQuery(results) {
+                    receivedResults = results;
+                    return results;
+                }
+            };
+
+            manager.register(plugin1);
+            manager.register(plugin2);
+
+            await pipeline.execute('project', {}, { objectName: 'project' }, async () => []);
+
+            expect(receivedResults).toEqual([{ modified: 'by-p1' }]);
+        });
+    });
+
+    describe('complete pipeline flow', () => {
+        it('should execute validation -> beforeQuery -> execute -> afterQuery', async () => {
+            const executionOrder: string[] = [];
+
+            const plugin: QueryProcessorPlugin = {
+                metadata: { name: 'complete', type: 'query_processor' },
+                async validateQuery() {
+                    executionOrder.push('validate');
+                },
+                async beforeQuery(query) {
+                    executionOrder.push('before');
+                    return query;
+                },
+                async afterQuery(results) {
+                    executionOrder.push('after');
+                    return results;
+                }
+            };
+
+            manager.register(plugin);
+
+            const mockExecutor = jest.fn(async () => {
+                executionOrder.push('execute');
+                return [];
+            });
+
+            await pipeline.execute('project', {}, { objectName: 'project' }, mockExecutor);
+
+            expect(executionOrder).toEqual(['validate', 'before', 'execute', 'after']);
+        });
+
+        it('should pass context to all hooks', async () => {
+            const receivedContexts: QueryProcessorContext[] = [];
+
+            const plugin: QueryProcessorPlugin = {
+                metadata: { name: 'ctx-test', type: 'query_processor' },
+                async validateQuery(query, context) {
+                    receivedContexts.push(context);
+                },
+                async beforeQuery(query, context) {
+                    receivedContexts.push(context);
+                    return query;
+                },
+                async afterQuery(results, context) {
+                    receivedContexts.push(context);
+                    return results;
+                }
+            };
+
+            manager.register(plugin);
+
+            const testContext = {
+                objectName: 'project',
+                user: { id: 'user-123' }
+            };
+
+            await pipeline.execute('project', {}, testContext, async () => []);
+
+            expect(receivedContexts).toHaveLength(3);
+            receivedContexts.forEach(ctx => {
+                expect(ctx.objectName).toBe('project');
+                expect(ctx.user).toEqual({ id: 'user-123' });
+            });
+        });
+    });
+
+    describe('error handling', () => {
+        it('should throw PipelineError with plugin name on validation failure', async () => {
+            const plugin: QueryProcessorPlugin = {
+                metadata: { name: 'bad-validator', type: 'query_processor' },
+                async validateQuery() {
+                    throw new Error('Invalid query');
+                }
+            };
+
+            manager.register(plugin);
+
+            try {
+                await pipeline.execute('project', {}, { objectName: 'project' }, async () => []);
+                fail('Should have thrown');
+            } catch (error) {
+                expect(error).toBeInstanceOf(PipelineError);
+                const pipelineError = error as PipelineError;
+                expect(pipelineError.pluginName).toBe('bad-validator');
+                expect(pipelineError.code).toBe('VALIDATION_FAILED');
+            }
+        });
+
+        it('should throw PipelineError on beforeQuery failure', async () => {
+            const plugin: QueryProcessorPlugin = {
+                metadata: { name: 'bad-before', type: 'query_processor' },
+                async beforeQuery() {
+                    throw new Error('Transform failed');
+                }
+            };
+
+            manager.register(plugin);
+
+            try {
+                await pipeline.execute('project', {}, { objectName: 'project' }, async () => []);
+                fail('Should have thrown');
+            } catch (error) {
+                expect(error).toBeInstanceOf(PipelineError);
+                const pipelineError = error as PipelineError;
+                expect(pipelineError.pluginName).toBe('bad-before');
+                expect(pipelineError.code).toBe('EXECUTION_FAILED');
+            }
+        });
+
+        it('should throw PipelineError on afterQuery failure', async () => {
+            const plugin: QueryProcessorPlugin = {
+                metadata: { name: 'bad-after', type: 'query_processor' },
+                async afterQuery() {
+                    throw new Error('Transform failed');
+                }
+            };
+
+            manager.register(plugin);
+
+            try {
+                await pipeline.execute('project', {}, { objectName: 'project' }, async () => []);
+                fail('Should have thrown');
+            } catch (error) {
+                expect(error).toBeInstanceOf(PipelineError);
+                const pipelineError = error as PipelineError;
+                expect(pipelineError.pluginName).toBe('bad-after');
+                expect(pipelineError.code).toBe('EXECUTION_FAILED');
+            }
+        });
+    });
+});
diff --git a/packages/runtime/core/test/runtime.test.ts b/packages/runtime/core/test/runtime.test.ts
new file mode 100644
index 00000000..8ab7fd27
--- /dev/null
+++ b/packages/runtime/core/test/runtime.test.ts
@@ -0,0 +1,261 @@
+/**
+ * ObjectQL
+ * Copyright (c) 2026-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import { createRuntime } from '../src/runtime';
+import { BasePlugin, QueryProcessorPlugin } from '@objectql/types';
+
+describe('Runtime Integration', () => {
+    describe('createRuntime factory', () => {
+        it('should create runtime with no plugins', () => {
+            const runtime = createRuntime();
+            expect(runtime).toBeDefined();
+            expect(runtime.pluginManager).toBeDefined();
+        });
+
+        it('should create runtime with plugins', () => {
+            const plugin: BasePlugin = {
+                metadata: { name: 'test' }
+            };
+
+            const runtime = createRuntime({ plugins: [plugin] });
+            expect(runtime.pluginManager.get('test')).toBe(plugin);
+        });
+    });
+
+    describe('runtime initialization', () => {
+        it('should initialize plugins on init()', async () => {
+            const setupCalls: string[] = [];
+
+            const plugin1: BasePlugin = {
+                metadata: { name: 'p1' },
+                async setup() {
+                    setupCalls.push('p1');
+                }
+            };
+
+            const plugin2: BasePlugin = {
+                metadata: { name: 'p2', dependencies: ['p1'] },
+                async setup() {
+                    setupCalls.push('p2');
+                }
+            };
+
+            const runtime = createRuntime({ plugins: [plugin2, plugin1] });
+            await runtime.init();
+
+            expect(setupCalls).toEqual(['p1', 'p2']);
+        });
+
+        it('should pass runtime instance to plugin setup', async () => {
+            let receivedRuntime: any;
+
+            const plugin: BasePlugin = {
+                metadata: { name: 'test' },
+                async setup(runtime) {
+                    receivedRuntime = runtime;
+                }
+            };
+
+            const runtime = createRuntime({ plugins: [plugin] });
+            await runtime.init();
+
+            expect(receivedRuntime).toBe(runtime);
+        });
+    });
+
+    describe('query execution', () => {
+        it('should require query executor to be set', async () => {
+            const runtime = createRuntime();
+            await runtime.init();
+
+            await expect(
+                runtime.query('project', {})
+            ).rejects.toThrow('Query executor not set');
+        });
+
+        it('should execute query through pipeline', async () => {
+            const mockExecutor = jest.fn().mockResolvedValue([
+                { id: 1, name: 'Project 1' }
+            ]);
+
+            const runtime = createRuntime();
+            runtime.setQueryExecutor(mockExecutor);
+            await runtime.init();
+
+            const results = await runtime.query('project', {
+                filters: [['status', '=', 'active']]
+            });
+
+            expect(results).toEqual([{ id: 1, name: 'Project 1' }]);
+            expect(mockExecutor).toHaveBeenCalledWith('project', {
+                filters: [['status', '=', 'active']]
+            });
+        });
+
+        it('should execute query with context', async () => {
+            let receivedContext: any;
+
+            const plugin: QueryProcessorPlugin = {
+                metadata: { name: 'ctx-plugin', type: 'query_processor' },
+                async beforeQuery(query, context) {
+                    receivedContext = context;
+                    return query;
+                }
+            };
+
+            const runtime = createRuntime({ plugins: [plugin] });
+            runtime.setQueryExecutor(async () => []);
+            await runtime.init();
+
+            await runtime.query('project', {}, {
+                user: { id: 'user-123' }
+            });
+
+            expect(receivedContext).toMatchObject({
+                objectName: 'project',
+                user: { id: 'user-123' }
+            });
+        });
+    });
+
+    describe('complete workflow demonstration', () => {
+        it('should demonstrate plugin dependency ordering and query processing', async () => {
+            const executionLog: string[] = [];
+
+            // Plugin A: Base plugin (no dependencies)
+            const pluginA: BasePlugin = {
+                metadata: {
+                    name: 'plugin-a',
+                    version: '1.0.0',
+                    type: 'extension'
+                },
+                async setup(runtime) {
+                    executionLog.push('setup-a');
+                }
+            };
+
+            // Plugin B: Depends on A
+            const pluginB: QueryProcessorPlugin = {
+                metadata: {
+                    name: 'plugin-b',
+                    version: '1.0.0',
+                    type: 'query_processor',
+                    dependencies: ['plugin-a']
+                },
+                async setup(runtime) {
+                    executionLog.push('setup-b');
+                },
+                async beforeQuery(query) {
+                    executionLog.push('before-b');
+                    return { ...query, addedByB: true } as any;
+                },
+                async afterQuery(results) {
+                    executionLog.push('after-b');
+                    return results.map(r => ({ ...r, decoratedByB: true }));
+                }
+            };
+
+            // Plugin C: Depends on B (transitive dependency on A)
+            const pluginC: QueryProcessorPlugin = {
+                metadata: {
+                    name: 'plugin-c',
+                    version: '1.0.0',
+                    type: 'query_processor',
+                    dependencies: ['plugin-b']
+                },
+                async setup(runtime) {
+                    executionLog.push('setup-c');
+                },
+                async validateQuery(query) {
+                    executionLog.push('validate-c');
+                },
+                async beforeQuery(query) {
+                    executionLog.push('before-c');
+                    return { ...query, addedByC: true } as any;
+                },
+                async afterQuery(results) {
+                    executionLog.push('after-c');
+                    return results.map(r => ({ ...r, decoratedByC: true }));
+                }
+            };
+
+            // Create runtime with plugins in random order
+            const runtime = createRuntime({
+                plugins: [pluginC, pluginA, pluginB]
+            });
+
+            // Set query executor
+            const mockData = [{ id: 1, name: 'Test' }];
+            runtime.setQueryExecutor(async (objectName, query) => {
+                executionLog.push('execute');
+                return mockData;
+            });
+
+            // Initialize runtime (should setup in dependency order)
+            await runtime.init();
+
+            // Execute query
+            const results = await runtime.query('project', {
+                filters: [['status', '=', 'active']]
+            });
+
+            // Verify setup order (A -> B -> C)
+            expect(executionLog.slice(0, 3)).toEqual(['setup-a', 'setup-b', 'setup-c']);
+
+            // Verify execution order
+            expect(executionLog).toEqual([
+                'setup-a',        // Setup phase (dependency order)
+                'setup-b',
+                'setup-c',
+                'validate-c',     // Validation phase (only C has validator)
+                'before-c',       // Before phase (C then B - registration order)
+                'before-b',
+                'execute',        // Execution
+                'after-c',        // After phase (C then B - registration order)
+                'after-b'
+            ]);
+
+            // Verify results were transformed by both plugins
+            expect(results).toEqual([{
+                id: 1,
+                name: 'Test',
+                decoratedByB: true,
+                decoratedByC: true
+            }]);
+        });
+    });
+
+    describe('runtime shutdown', () => {
+        it('should shutdown all plugins', async () => {
+            const teardownCalls: string[] = [];
+
+            const plugin1: BasePlugin = {
+                metadata: { name: 'p1' },
+                async setup() {},
+                async teardown() {
+                    teardownCalls.push('p1');
+                }
+            };
+
+            const plugin2: BasePlugin = {
+                metadata: { name: 'p2', dependencies: ['p1'] },
+                async setup() {},
+                async teardown() {
+                    teardownCalls.push('p2');
+                }
+            };
+
+            const runtime = createRuntime({ plugins: [plugin1, plugin2] });
+            await runtime.init();
+            await runtime.shutdown();
+
+            // Should teardown in reverse order
+            expect(teardownCalls).toEqual(['p2', 'p1']);
+        });
+    });
+});
diff --git a/packages/runtime/core/tsconfig.json b/packages/runtime/core/tsconfig.json
new file mode 100644
index 00000000..c090e086
--- /dev/null
+++ b/packages/runtime/core/tsconfig.json
@@ -0,0 +1,12 @@
+{
+  "extends": "../../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src",
+    "composite": true
+  },
+  "include": ["src/**/*"],
+  "references": [
+    { "path": "../../foundation/types" }
+  ]
+}
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 9fe393ec..4a52badd 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -513,6 +513,19 @@ importers:
         specifier: ^2.4.0
         version: 2.4.0
 
+  packages/runtime/core:
+    dependencies:
+      '@objectql/types':
+        specifier: workspace:*
+        version: link:../../foundation/types
+    devDependencies:
+      '@types/node':
+        specifier: ^20.10.0
+        version: 20.19.29
+      typescript:
+        specifier: ^5.3.0
+        version: 5.9.3
+
   packages/runtime/server:
     dependencies:
       '@graphql-tools/schema':