@kb-labs/core-runtime 1.0.0

package/dist/index.d.cts

@@ -0,0 +1,2267 @@
+import { CreateEnvironmentRequest, EnvironmentDescriptor, EnvironmentStatusResult, EnvironmentLease, MaterializeWorkspaceRequest, WorkspaceDescriptor, AttachWorkspaceRequest, WorkspaceAttachment, WorkspaceStatusResult, WorkspaceProviderCapabilities, CaptureSnapshotRequest, SnapshotDescriptor, RestoreSnapshotRequest, RestoreSnapshotResult, SnapshotStatusResult, SnapshotGarbageCollectRequest, SnapshotGarbageCollectResult, SnapshotProviderCapabilities, IExecutionBackend, ExecutionRequest, ExecutionResult, CreateRunRequest, RunRecord, IAnalytics, IVectorStore, ILLM, IEmbeddings, ICache, IConfig, IStorage, ILogger, IEventBus, IInvoke, IArtifacts, ILogReader, IWorkflowEngine, IJobScheduler, ICronManager, IResourceManager, TenantQuotas, ResourceType, ResourceSlot, ResourceAvailability, JobDefinition, JobHandle, CronExpression, JobFilter, CronHandler, CronJob, WorkflowOptions, WorkflowRun, WorkflowFilter, VectorFilter, VectorSearchResult, VectorRecord, LLMOptions, LLMResponse, LLMProtocolCapabilities, LLMMessage, LLMToolCallOptions, LLMToolCallResponse } from '@kb-labs/core-platform';
+import { IResourceBroker, RateLimitConfig, RateLimitPreset } from '@kb-labs/core-resource-broker';
+import { AnalyticsContext, IStorage as IStorage$1, StorageMetadata, ISQLDatabase, SQLQueryResult, SQLTransaction, IDocumentDatabase, BaseDocument, DocumentFilter, FindOptions, DocumentUpdate } from '@kb-labs/core-platform/adapters';
+export { BulkTransfer, BulkTransferHelper, BulkTransferOptions, CircuitOpenError, IPCServer, IPCTransport, ITransport, OPERATION_TIMEOUTS, PendingRequest, TimeoutError, TransportConfig, TransportError, UnixSocketConfig, UnixSocketServer, UnixSocketServerConfig, UnixSocketTransport, createIPCServer, createIPCTransport, createUnixSocketTransport, getOperationTimeout, isRetryableError, selectTimeout } from '@kb-labs/core-ipc';
+import { AdapterCall, AdapterResponse, AdapterType, AdapterCallContext } from '@kb-labs/core-platform/serializable';
+export { createNoOpPlatform } from '@kb-labs/core-platform/noop';
+
+/**
+ * @module @kb-labs/core-runtime/environment-manager
+ * Runtime manager for long-lived environment providers.
+ */
+
+interface EnvironmentManagerOptions {
+    janitorIntervalMs?: number;
+    janitorBatchSize?: number;
+}
+/**
+ * Environment manager facade over `environment` adapter token.
+ *
+ * Keeps provider access in one place and centralizes diagnostics.
+ */
+declare class EnvironmentManager {
+    private readonly platform;
+    private readonly store?;
+    private readonly janitorIntervalMs;
+    private readonly janitorBatchSize;
+    private janitorTimer?;
+    constructor(platform: Pick<PlatformContainer, 'getAdapter' | 'logger'>, options?: EnvironmentManagerOptions);
+    /**
+     * Check whether environment provider is configured.
+     */
+    hasProvider(): boolean;
+    /**
+     * Create environment using configured provider.
+     */
+    createEnvironment(request: CreateEnvironmentRequest): Promise<EnvironmentDescriptor>;
+    /**
+     * Get environment status.
+     */
+    getEnvironmentStatus(environmentId: string): Promise<EnvironmentStatusResult>;
+    /**
+     * Destroy environment.
+     */
+    destroyEnvironment(environmentId: string, reason?: string): Promise<void>;
+    /**
+     * Renew environment lease if provider supports it.
+     */
+    renewEnvironmentLease(environmentId: string, ttlMs: number): Promise<EnvironmentLease>;
+    /**
+     * Start periodic cleanup for expired leases.
+     */
+    startJanitor(): void;
+    /**
+     * Stop janitor timer.
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Cleanup expired active leases.
+     */
+    cleanupExpiredLeases(now?: Date): Promise<number>;
+    private getProviderOrThrow;
+    private persistLeaseState;
+    private appendEvent;
+    private safePersist;
+}
+
+/**
+ * @module @kb-labs/core-runtime/workspace-manager
+ * Runtime manager for workspace providers.
+ */
+
+declare class WorkspaceManager {
+    private readonly platform;
+    constructor(platform: Pick<PlatformContainer, 'getAdapter'>);
+    /**
+     * Check whether workspace provider is configured.
+     */
+    hasProvider(): boolean;
+    /**
+     * Materialize a workspace.
+     */
+    materializeWorkspace(request: MaterializeWorkspaceRequest): Promise<WorkspaceDescriptor>;
+    /**
+     * Attach workspace to environment.
+     */
+    attachWorkspace(request: AttachWorkspaceRequest): Promise<WorkspaceAttachment>;
+    /**
+     * Release workspace attachment.
+     */
+    releaseWorkspace(workspaceId: string, environmentId?: string): Promise<void>;
+    /**
+     * Get workspace lifecycle status.
+     */
+    getWorkspaceStatus(workspaceId: string): Promise<WorkspaceStatusResult>;
+    /**
+     * Read provider capabilities.
+     */
+    getCapabilities(): WorkspaceProviderCapabilities;
+    /**
+     * Shutdown manager resources (reserved for future internal workers).
+     */
+    shutdown(): Promise<void>;
+    private getProviderOrThrow;
+}
+
+/**
+ * @module @kb-labs/core-runtime/snapshot-manager
+ * Runtime manager for snapshot providers.
+ */
+
+declare class SnapshotManager {
+    private readonly platform;
+    constructor(platform: Pick<PlatformContainer, 'getAdapter'>);
+    /**
+     * Check whether snapshot provider is configured.
+     */
+    hasProvider(): boolean;
+    /**
+     * Capture a new snapshot.
+     */
+    captureSnapshot(request: CaptureSnapshotRequest): Promise<SnapshotDescriptor>;
+    /**
+     * Restore an existing snapshot.
+     */
+    restoreSnapshot(request: RestoreSnapshotRequest): Promise<RestoreSnapshotResult>;
+    /**
+     * Read snapshot status.
+     */
+    getSnapshotStatus(snapshotId: string): Promise<SnapshotStatusResult>;
+    /**
+     * Delete snapshot by id.
+     */
+    deleteSnapshot(snapshotId: string): Promise<void>;
+    /**
+     * Run garbage collection if provider supports it.
+     */
+    garbageCollectSnapshots(request?: SnapshotGarbageCollectRequest): Promise<SnapshotGarbageCollectResult>;
+    /**
+     * Read provider capabilities.
+     */
+    getCapabilities(): SnapshotProviderCapabilities;
+    /**
+     * Shutdown manager resources (reserved for future internal workers).
+     */
+    shutdown(): Promise<void>;
+    private getProviderOrThrow;
+}
+
+/**
+ * @module @kb-labs/core-runtime/run-executor
+ * Bridge between run orchestration and execution backend.
+ */
+
+/**
+ * Request for run step execution.
+ */
+interface RunStepExecutionRequest {
+    runId: string;
+    stepId: string;
+    environmentId?: string;
+    execution: ExecutionRequest;
+}
+/**
+ * Run executor that enriches execution metadata with run/environment context.
+ */
+declare class RunExecutor {
+    private readonly executionBackend;
+    private readonly logger;
+    constructor(executionBackend: IExecutionBackend, logger: {
+        debug(message: string, meta?: Record<string, unknown>): void;
+    });
+    /**
+     * Execute one run step through the shared execution backend.
+     */
+    executeStep(request: RunStepExecutionRequest): Promise<ExecutionResult>;
+}
+
+/**
+ * @module @kb-labs/core-runtime/run-orchestrator
+ * Minimal run state machine orchestration skeleton.
+ */
+
+/**
+ * Full-cycle start request (MVP skeleton).
+ */
+interface StartFullCycleRequest {
+    run: CreateRunRequest;
+    environment: CreateEnvironmentRequest;
+    firstStep?: RunStepExecutionRequest['execution'];
+}
+/**
+ * In-memory orchestrator skeleton for phase 2 wiring.
+ */
+declare class RunOrchestrator {
+    private readonly environmentManager;
+    private readonly runExecutor;
+    private readonly logger;
+    private readonly runs;
+    constructor(environmentManager: EnvironmentManager, runExecutor: RunExecutor, logger: {
+        debug(message: string, meta?: Record<string, unknown>): void;
+    });
+    /**
+     * Create run record in memory.
+     */
+    createRun(input: CreateRunRequest): RunRecord;
+    /**
+     * Read run from in-memory store.
+     */
+    getRun(runId: string): RunRecord | undefined;
+    /**
+     * Start minimal full-cycle flow.
+     * queue -> provisioning -> executing -> completed/failed
+     */
+    startFullCycle(request: StartFullCycleRequest): Promise<RunRecord>;
+    private transition;
+    private getRunOrThrow;
+}
+
+/**
+ * @module @kb-labs/core-runtime/container
+ * Platform DI container.
+ */
+
+/**
+ * Core adapter types (known at compile time).
+ * These are the primary adapters that plugins see.
+ */
+interface CoreAdapterTypes {
+    analytics: IAnalytics;
+    vectorStore: IVectorStore;
+    llm: ILLM;
+    embeddings: IEmbeddings;
+    cache: ICache;
+    config: IConfig;
+    storage: IStorage;
+    logger: ILogger;
+    eventBus: IEventBus;
+    invoke: IInvoke;
+    artifacts: IArtifacts;
+}
+/**
+ * All adapter types (core + extensions).
+ * Extensions can be any type, not known at compile time.
+ */
+type AdapterTypes = CoreAdapterTypes & {
+    [key: string]: unknown;
+};
+/**
+ * Platform lifecycle phase.
+ */
+type PlatformLifecyclePhase = 'start' | 'ready' | 'beforeShutdown' | 'shutdown';
+/**
+ * Platform lifecycle event context.
+ */
+interface PlatformLifecycleContext {
+    phase: PlatformLifecyclePhase;
+    cwd?: string;
+    isChildProcess?: boolean;
+    reason?: string;
+    error?: unknown;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Platform lifecycle hooks.
+ */
+interface PlatformLifecycleHooks {
+    onStart?(context: PlatformLifecycleContext): void | Promise<void>;
+    onReady?(context: PlatformLifecycleContext): void | Promise<void>;
+    onBeforeShutdown?(context: PlatformLifecycleContext): void | Promise<void>;
+    onShutdown?(context: PlatformLifecycleContext): void | Promise<void>;
+    onError?(error: unknown, phase: PlatformLifecyclePhase, context: PlatformLifecycleContext): void | Promise<void>;
+}
+/**
+ * Platform DI container.
+ * Provides access to all platform services through lazy-loaded getters.
+ */
+declare class PlatformContainer {
+    private adapters;
+    private lifecycleHooks;
+    private initialized;
+    /**
+     * Set an adapter instance.
+     *
+     * Supports both core adapters (type-safe) and extension adapters (generic).
+     *
+     * @example
+     * ```typescript
+     * // Core adapter (type-safe)
+     * platform.setAdapter('logger', pinoLogger); // Type: ILogger
+     *
+     * // Extension adapter (requires explicit type)
+     * platform.setAdapter('logRingBuffer', ringBuffer); // Type: LogRingBufferAdapter
+     * ```
+     *
+     * @param key - Adapter key
+     * @param instance - Adapter instance
+     */
+    setAdapter<K extends keyof CoreAdapterTypes>(key: K, instance: CoreAdapterTypes[K]): void;
+    setAdapter<T = unknown>(key: string, instance: T): void;
+    /**
+     * Get an adapter instance.
+     *
+     * Two overloads:
+     * 1. Core adapters (logger, db, etc.) - type-safe, returns typed instance
+     * 2. Extension adapters (logRingBuffer, logPersistence, etc.) - generic, requires explicit type
+     *
+     * @example
+     * ```typescript
+     * // Core adapter (type-safe)
+     * const logger = platform.getAdapter('logger'); // ILogger | undefined
+     *
+     * // Extension adapter (requires explicit type)
+     * const buffer = platform.getAdapter<ILogRingBuffer>('logRingBuffer');
+     * ```
+     *
+     * @param key - Adapter key
+     */
+    getAdapter<K extends keyof CoreAdapterTypes>(key: K): CoreAdapterTypes[K] | undefined;
+    getAdapter<T = unknown>(key: string): T | undefined;
+    /**
+     * Check if an adapter is explicitly configured (not using fallback).
+     *
+     * @example
+     * ```typescript
+     * // Core adapter
+     * if (platform.hasAdapter('logger')) { ... }
+     *
+     * // Extension adapter
+     * if (platform.hasAdapter('logRingBuffer')) { ... }
+     * ```
+     *
+     * @param key - Adapter key
+     */
+    hasAdapter<K extends keyof CoreAdapterTypes>(key: K): boolean;
+    hasAdapter(key: string): boolean;
+    /**
+     * List all adapter names.
+     * Useful for debugging and discovery.
+     */
+    listAdapters(): string[];
+    /**
+     * Register platform lifecycle hooks.
+     * If hooks with this id already exist, they are replaced.
+     */
+    registerLifecycleHooks(id: string, hooks: PlatformLifecycleHooks): void;
+    /**
+     * Unregister platform lifecycle hooks by id.
+     */
+    unregisterLifecycleHooks(id: string): void;
+    /**
+     * List registered lifecycle hook ids.
+     */
+    listLifecycleHookIds(): string[];
+    /**
+     * Emit lifecycle phase to registered hooks.
+     */
+    emitLifecyclePhase(phase: PlatformLifecyclePhase, context?: Omit<PlatformLifecycleContext, 'phase'>): Promise<void>;
+    /**
+     * Emit lifecycle error to registered onError hooks.
+     */
+    emitLifecycleError(error: unknown, phase: PlatformLifecyclePhase, context?: Omit<PlatformLifecycleContext, 'phase'>): Promise<void>;
+    /**
+     * Check if a service is explicitly configured (not using fallback).
+     * @param service - Service name (e.g., 'llm', 'vectorStore', 'workflows')
+     * @returns true if service is configured, false if using NoOp/fallback
+     */
+    isConfigured(service: string): boolean;
+    /**
+     * Get list of all configured services (adapters + core features).
+     * Used for validating plugin platform requirements.
+     */
+    getConfiguredServices(): Set<string>;
+    /** Analytics adapter (fallback: NoOpAnalytics) */
+    get analytics(): IAnalytics;
+    /** Vector store adapter (fallback: MemoryVectorStore) */
+    get vectorStore(): IVectorStore;
+    /** LLM adapter (fallback: MockLLM) */
+    get llm(): ILLM;
+    /** Embeddings adapter (fallback: MockEmbeddings) */
+    get embeddings(): IEmbeddings;
+    /** Cache adapter (fallback: MemoryCache) */
+    get cache(): ICache;
+    /** Config adapter (fallback: NoOpConfig) */
+    get config(): IConfig;
+    /** Storage adapter (fallback: MemoryStorage) */
+    get storage(): IStorage;
+    /** Logger adapter (fallback: ConsoleLogger) */
+    get logger(): ILogger;
+    /** Event bus adapter (fallback: MemoryEventBus) */
+    get eventBus(): IEventBus;
+    /** Inter-plugin invocation adapter (fallback: NoOpInvoke) */
+    get invoke(): IInvoke;
+    /** Artifact storage adapter (fallback: MemoryArtifacts) */
+    get artifacts(): IArtifacts;
+    private _logQueryService?;
+    /**
+     * Unified log query service.
+     * Automatically uses configured backends (logPersistence, logRingBuffer).
+     *
+     * @example
+     * ```typescript
+     * // Query logs
+     * const result = await platform.logs.query({ level: 'error' });
+     *
+     * // Get log by ID
+     * const log = await platform.logs.getById('log-123');
+     *
+     * // Full-text search
+     * const results = await platform.logs.search('authentication failed');
+     *
+     * // Subscribe to real-time stream
+     * const unsubscribe = platform.logs.subscribe((log) => console.log(log));
+     * ```
+     */
+    get logs(): ILogReader;
+    private _workflows?;
+    private _jobs?;
+    private _cron?;
+    private _resources?;
+    private _resourceBroker?;
+    private _socketServer?;
+    private _executionBackend?;
+    private _environmentManager?;
+    private _workspaceManager?;
+    private _snapshotManager?;
+    private _runExecutor?;
+    private _runOrchestrator?;
+    /** Workflow engine (throws if not initialized) */
+    get workflows(): IWorkflowEngine;
+    /** Job scheduler (throws if not initialized) */
+    get jobs(): IJobScheduler;
+    /** Cron manager (throws if not initialized) */
+    get cron(): ICronManager;
+    /** Resource manager (throws if not initialized) */
+    get resources(): IResourceManager;
+    /**
+     * Resource broker for rate limiting, queueing, and retry.
+     * @throws Error if not initialized
+     */
+    get resourceBroker(): IResourceBroker;
+    /**
+     * Check if resource broker is initialized.
+     */
+    get hasResourceBroker(): boolean;
+    /**
+     * Initialize core features.
+     * Called internally by initPlatform().
+     */
+    initCoreFeatures(workflows: IWorkflowEngine, jobs: IJobScheduler, cron: ICronManager, resources: IResourceManager): void;
+    /**
+     * Initialize resource broker.
+     * Called internally by initPlatform().
+     */
+    initResourceBroker(broker: IResourceBroker): void;
+    /**
+     * Initialize Unix socket server.
+     * Called internally by initPlatform() in parent process.
+     */
+    initSocketServer(server: {
+        getSocketPath(): string;
+    }): void;
+    /**
+     * Get socket path for IPC communication.
+     * Returns undefined if not running in parent process.
+     */
+    getSocketPath(): string | undefined;
+    /**
+     * Initialize execution backend.
+     * Called internally by initPlatform() AFTER adapters, BEFORE core features.
+     *
+     * @param backend - ExecutionBackend instance (from @kb-labs/plugin-execution)
+     */
+    initExecutionBackend(backend: IExecutionBackend): void;
+    /**
+     * Get execution backend.
+     * Returns the initialized backend or throws if not initialized.
+     *
+     * @throws Error if ExecutionBackend not initialized via initPlatform()
+     * @returns ExecutionBackend instance
+     */
+    get executionBackend(): IExecutionBackend;
+    /**
+     * Check if execution backend is initialized.
+     */
+    get hasExecutionBackend(): boolean;
+    /**
+     * Initialize orchestration services.
+     * Called internally by initPlatform() after ExecutionBackend init.
+     */
+    initOrchestrationServices(environmentManager: EnvironmentManager, runExecutor: RunExecutor, runOrchestrator: RunOrchestrator): void;
+    /**
+     * Initialize infrastructure capability services.
+     * Called internally by initPlatform().
+     */
+    initCapabilityServices(workspaceManager: WorkspaceManager, snapshotManager: SnapshotManager): void;
+    /**
+     * Environment manager service.
+     */
+    get environmentManager(): EnvironmentManager;
+    /**
+     * Workspace manager service.
+     */
+    get workspaceManager(): WorkspaceManager;
+    /**
+     * Snapshot manager service.
+     */
+    get snapshotManager(): SnapshotManager;
+    /**
+     * Run executor service.
+     */
+    get runExecutor(): RunExecutor;
+    /**
+     * Run orchestrator service.
+     */
+    get runOrchestrator(): RunOrchestrator;
+    /**
+     * Check if platform is initialized.
+     */
+    get isInitialized(): boolean;
+    /**
+     * Reset platform to initial state.
+     * Clears all adapters and core features.
+     * Used primarily for testing.
+     */
+    reset(): void;
+    /**
+     * Shutdown platform gracefully.
+     * Closes all resources, stops workers, cleanup.
+     */
+    shutdown(): Promise<void>;
+}
+/**
+ * Type augmentation for process to track platform singleton.
+ * This makes TypeScript aware of our platform storage.
+ */
+declare global {
+    var __KB_PLATFORM_SINGLETON__: PlatformContainer | undefined;
+}
+/**
+ * Global platform container singleton.
+ *
+ * Uses Symbol.for() + process for TRUE cross-realm singleton:
+ * - Works across CJS (CLI bin.cjs) and ESM (sandbox workers)
+ * - All worker threads share the same process object
+ * - Each Docker container gets its own process (correct isolation!)
+ *
+ * This ensures:
+ * ✅ One QdrantVectorStore instance per Node.js process
+ * ✅ One Logger instance per Node.js process
+ * ✅ One Analytics adapter per Node.js process
+ * ✅ All sandbox workers share adapters (resource efficiency)
+ * ✅ Docker containers are isolated (security for paranoid mode)
+ */
+declare const platform: PlatformContainer;
+
+/**
+ * @module @kb-labs/core-runtime/config
+ * Platform configuration types.
+ */
+
+/**
+ * Adapter value type.
+ * - string: Single adapter package path
+ * - string[]: Multiple adapter packages (first = primary/default, others available via adapterLoader)
+ * - null: NoOp adapter
+ *
+ * @example
+ * ```typescript
+ * // Single adapter
+ * llm: "@kb-labs/adapters-openai"
+ *
+ * // Multiple adapters (multi-provider setup)
+ * llm: ["@kb-labs/adapters-openai", "@kb-labs/adapters-vibeproxy"]
+ *
+ * // NoOp/disabled
+ * analytics: null
+ * ```
+ */
+type AdapterValue = string | string[] | null;
+/**
+ * Platform adapter configuration.
+ * Each key is the adapter name, value can be:
+ * - string: Single adapter package path
+ * - string[]: Multiple adapters (first = primary, rest available via routing/options)
+ * - null: NoOp adapter
+ */
+interface AdaptersConfig {
+    /** Analytics adapter package(s) (e.g., "@kb-labs/analytics-adapter" or ["@kb-labs/analytics-file", "@kb-labs/analytics-posthog"]) */
+    analytics?: AdapterValue;
+    /** Vector store adapter package(s) (e.g., "@kb-labs/adapters-qdrant") */
+    vectorStore?: AdapterValue;
+    /** LLM adapter package(s) (e.g., "@kb-labs/adapters-openai" or ["@kb-labs/adapters-openai", "@kb-labs/adapters-vibeproxy"]) */
+    llm?: AdapterValue;
+    /** Embeddings adapter package(s) (e.g., "@kb-labs/adapters-openai/embeddings") */
+    embeddings?: AdapterValue;
+    /** Cache adapter package(s) (e.g., "@kb-labs/adapters-redis") */
+    cache?: AdapterValue;
+    /** Storage adapter package(s) (e.g., "@kb-labs/adapters-fs") */
+    storage?: AdapterValue;
+    /** Logger adapter package(s) (e.g., "@kb-labs/adapters-pino") */
+    logger?: AdapterValue;
+    /** Event bus adapter package(s) */
+    eventBus?: AdapterValue;
+    /** Environment provider adapter package(s) (e.g., "@kb-labs/adapters-environment-docker") */
+    environment?: AdapterValue;
+    /** Workspace provider adapter package(s) (e.g., "@kb-labs/adapters-workspace-localfs") */
+    workspace?: AdapterValue;
+    /** Snapshot provider adapter package(s) (e.g., "@kb-labs/adapters-snapshot-localfs") */
+    snapshot?: AdapterValue;
+}
+/**
+ * Resource manager configuration.
+ */
+interface ResourcesConfig {
+    /** Default quotas for tenants without explicit quotas */
+    defaultQuotas?: Partial<TenantQuotas>;
+}
+/**
+ * Job scheduler configuration.
+ */
+interface JobsConfig {
+    /** Maximum concurrent jobs per tenant */
+    maxConcurrent?: number;
+    /** Poll interval in milliseconds for job queue */
+    pollInterval?: number;
+}
+/**
+ * Workflow engine configuration.
+ */
+interface WorkflowsConfig {
+    /** Maximum concurrent workflows per tenant */
+    maxConcurrent?: number;
+    /** Default workflow timeout in milliseconds */
+    defaultTimeout?: number;
+}
+/**
+ * Execution backend configuration.
+ * Determines how plugins execute (in-process, worker-pool, remote).
+ */
+interface ExecutionConfig {
+    /**
+     * Execution mode:
+     * - 'auto' (default): Auto-detect from environment (EXECUTION_MODE, KUBERNETES_SERVICE_HOST)
+     * - 'in-process': Same process, no isolation (dev mode, fast iteration)
+     * - 'worker-pool': Worker pool with fault isolation (production, single-node)
+     * - 'remote': Remote executor service (Phase 3, distributed fleet)
+     * @default 'auto'
+     */
+    mode?: 'auto' | 'in-process' | 'worker-pool' | 'remote';
+    /**
+     * Worker pool options (used when mode=worker-pool or auto-detected).
+     */
+    workerPool?: {
+        /** Minimum workers to keep alive @default 2 */
+        min?: number;
+        /** Maximum concurrent workers @default 10 */
+        max?: number;
+        /** Max requests per worker before recycling @default 1000 */
+        maxRequestsPerWorker?: number;
+        /** Max worker uptime before recycling (ms) @default 1800000 (30min) */
+        maxUptimeMsPerWorker?: number;
+        /** Max concurrent requests per plugin (optional) */
+        maxConcurrentPerPlugin?: number;
+        /** Warmup policy */
+        warmup?: {
+            /**
+             * Warmup mode (matches plugin-execution types):
+             * - 'none': No warmup (cold start on first request)
+             * - 'top-n': Warmup top N most-used handlers
+             * - 'marked': Warmup handlers marked with warmup: true in manifest
+             * @default 'none'
+             */
+            mode?: 'none' | 'top-n' | 'marked';
+            /** Warmup top N most used handlers (for top-n mode) @default 5 */
+            topN?: number;
+            /** Max handlers to warmup (safety limit) @default 20 */
+            maxHandlers?: number;
+        };
+    };
+    /**
+     * Remote executor options (used when mode=remote, Phase 3).
+     */
+    remote?: {
+        /** Remote executor service endpoint (gRPC or HTTP) */
+        endpoint?: string;
+    };
+}
+/**
+ * Resource broker configuration for rate limiting and queue management.
+ */
+interface ResourceBrokerConfig {
+    /**
+     * Use distributed backend via StateBroker.
+     * false = InMemoryRateLimitBackend (single process)
+     * true = StateBrokerRateLimitBackend (distributed, requires StateBroker daemon)
+     * @default false
+     */
+    distributed?: boolean;
+    /**
+     * LLM resource configuration.
+     */
+    llm?: {
+        /** Rate limits (preset name or custom config) */
+        rateLimits?: RateLimitConfig | RateLimitPreset;
+        /** Maximum retry attempts */
+        maxRetries?: number;
+        /** Request timeout in ms */
+        timeout?: number;
+    };
+    /**
+     * Embeddings resource configuration.
+     */
+    embeddings?: {
+        /** Rate limits (preset name or custom config) */
+        rateLimits?: RateLimitConfig | RateLimitPreset;
+        /** Maximum retry attempts */
+        maxRetries?: number;
+        /** Request timeout in ms */
+        timeout?: number;
+    };
+    /**
+     * Vector store resource configuration.
+     */
+    vectorStore?: {
+        /** Maximum concurrent requests */
+        maxConcurrent?: number;
+        /** Maximum retry attempts */
+        maxRetries?: number;
+        /** Request timeout in ms */
+        timeout?: number;
+    };
+}
+/**
+ * Core features configuration.
+ */
+interface CoreFeaturesConfig {
+    /** Resource manager configuration */
+    resources?: ResourcesConfig;
+    /** Job scheduler configuration */
+    jobs?: JobsConfig;
+    /** Workflow engine configuration */
+    workflows?: WorkflowsConfig;
+    /** Resource broker configuration */
+    resourceBroker?: ResourceBrokerConfig;
+}
+/**
+ * Full platform configuration.
+ */
+interface PlatformConfig {
+    /** Adapter packages configuration */
+    adapters?: AdaptersConfig;
+    /** Optional adapter-specific configuration passed to createAdapter(config) */
+    adapterOptions?: Partial<Record<keyof AdaptersConfig, unknown>>;
+    /** Core features configuration */
+    core?: CoreFeaturesConfig;
+    /** Execution backend configuration (NEW: unified plugin execution) */
+    execution?: ExecutionConfig;
+}
+
+/**
+ * @module @kb-labs/core-runtime/loader
+ * Platform initialization and adapter loading.
+ */
+
+/**
+ * Initialize the platform with configuration.
+ * Loads adapters and initializes core features.
+ *
+ * @param config - Platform configuration
+ * @param cwd - Workspace root directory (defaults to process.cwd())
+ * @returns Initialized platform container
+ *
+ * @example
+ * ```typescript
+ * await initPlatform({
+ *   adapters: {
+ *     analytics: '@kb-labs/analytics-adapter',
+ *     vectorStore: '@kb-labs/adapters-qdrant',
+ *     llm: '@kb-labs/adapters-openai',
+ *   },
+ *   core: {
+ *     resources: { defaultQuotas: { ... } },
+ *     jobs: { maxConcurrent: 10 },
+ *   },
+ * });
+ * ```
+ */
+declare function initPlatform(config?: PlatformConfig, cwd?: string, uiProvider?: (hostType: string) => any): Promise<PlatformContainer>;
+/**
+ * Reset the platform to initial state (for testing).
+ * Clears all adapters and core features.
+ * Platform will use NoOp fallbacks until re-initialized.
+ *
+ * @example
+ * ```typescript
+ * // Before test
+ * resetPlatform();
+ * await initPlatform({ adapters: { llm: mockLLM } });
+ *
+ * // After test
+ * resetPlatform();
+ * ```
+ */
+declare function resetPlatform(): void;
+
+/**
+ * @module @kb-labs/core-runtime/discover-adapters
+ * Auto-discovery of adapters from workspace packages.
+ *
+ * Similar to CLI plugin discovery, this scans kb-labs-adapters/packages/*
+ * and loads adapters by file path (not package name).
+ */
+/**
+ * Discovered adapter info
+ */
+interface DiscoveredAdapter {
+    /** Package name (e.g., "@kb-labs/adapters-openai") */
+    packageName: string;
+    /** Absolute path to package root */
+    pkgRoot: string;
+    /** Adapter factory function */
+    createAdapter: (config?: any) => any;
+    /** Adapter module (full exports) */
+    module: any;
+}
+/**
+ * Discover adapters from workspace packages.
+ * Scans kb-labs-adapters/packages/* and loads built adapters.
+ *
+ * @param cwd - Workspace root directory
+ * @returns Map of package names to adapter info
+ *
+ * @example
+ * ```typescript
+ * const adapters = await discoverAdapters('/Users/kb-labs');
+ * const openai = adapters.get('@kb-labs/adapters-openai');
+ * if (openai) {
+ *   const llm = openai.createAdapter({ model: 'gpt-4' });
+ * }
+ * ```
+ */
+declare function discoverAdapters(cwd: string): Promise<Map<string, DiscoveredAdapter>>;
+/**
+ * Resolve adapter path - tries discovery first, falls back to package name import.
+ *
+ * @param adapterPath - Package name or file path
+ * @param cwd - Workspace root directory
+ * @returns Adapter factory function
+ *
+ * @example
+ * ```typescript
+ * // Try to discover first (workspace)
+ * const adapter = await resolveAdapter('@kb-labs/adapters-openai', cwd);
+ *
+ * // Falls back to dynamic import if not found in workspace
+ * const adapter = await resolveAdapter('@kb-labs/adapters-openai', cwd);
+ * ```
+ */
+declare function resolveAdapter(adapterPath: string, cwd: string): Promise<((config?: any) => any) | null>;
+
+/**
+ * @module @kb-labs/core-runtime/analytics-context
+ * Auto-detection of analytics context (source, actor, runId) for event enrichment.
+ *
+ * See ADR-0040: Analytics V1 Auto-Enrichment
+ */
+
+/**
+ * Create AnalyticsContext with auto-detection of source, actor, and runId.
+ *
+ * Detection logic:
+ * - **Source**: Reads package.json from cwd for product name and version
+ * - **Actor**: Detects from CI environment variables or git config
+ *   - CI mode: Checks CI=true, GITHUB_ACTIONS, GITLAB_CI, etc.
+ *   - User mode: Executes `git config user.name` and `git config user.email`
+ * - **RunId**: Generates unique UUID per execution (correlates events in single CLI invocation)
+ * - **Context**: Adds workspace path, git branch (if available)
+ *
+ * @param cwd - Workspace root directory
+ * @returns AnalyticsContext with auto-populated metadata
+ *
+ * @example
+ * ```typescript
+ * const context = await createAnalyticsContext('/path/to/workspace');
+ * // {
+ * //   source: { product: '@kb-labs/cli', version: '1.0.0' },
+ * //   runId: 'f47ac10b-58cc-4372-a567-0e02b2c3d479',
+ * //   actor: { type: 'user', id: 'user@example.com', name: 'John Doe' },
+ * //   ctx: { workspace: '/path/to/workspace', branch: 'main' }
+ * // }
+ * ```
+ */
+declare function createAnalyticsContext(cwd: string): Promise<AnalyticsContext>;
+
+/**
+ * @module @kb-labs/core-runtime/core/resource-manager
+ * In-memory resource manager with quota enforcement.
+ */
+
+interface ResourceManagerConfig {
+    /** Default quotas for new tenants */
+    defaultQuotas?: Partial<TenantQuotas>;
+    /** Slot expiration check interval in ms (default: 30000) */
+    expirationCheckInterval?: number;
+}
+/**
+ * In-memory resource manager with quota enforcement.
+ * Tracks resource slots per tenant and enforces limits.
+ */
+declare class ResourceManager implements IResourceManager {
+    private cache;
+    private logger;
+    private slots;
+    private tenantSlots;
+    private quotas;
+    private defaultQuotas;
+    private idCounter;
+    private expirationTimer?;
+    constructor(cache: ICache, logger: ILogger, config?: ResourceManagerConfig);
+    /**
+     * Acquire a resource slot for a tenant.
+     * Returns null if quota exceeded.
+     *
+     * @param resource - Type of resource to acquire
+     * @param tenantId - Tenant identifier
+     * @param timeout - Optional slot expiration timeout in ms
+     * @returns Resource slot if available, null if quota exceeded
+     */
+    acquireSlot(resource: ResourceType, tenantId: string, timeout?: number): Promise<ResourceSlot | null>;
+    /**
+     * Release a previously acquired resource slot.
+     * Frees up quota for the tenant.
+     *
+     * @param slot - Slot to release
+     */
+    releaseSlot(slot: ResourceSlot): Promise<void>;
+    /**
+     * Get resource availability statistics.
+     * If tenantId provided, returns tenant-specific stats.
+     * Otherwise, returns global platform stats.
+     *
+     * @param resource - Type of resource
+     * @param tenantId - Optional tenant filter
+     * @returns Resource availability stats
+     */
+    getAvailability(resource: ResourceType, tenantId?: string): Promise<ResourceAvailability>;
+    /**
+     * Set custom quotas for a tenant.
+     * Merges with default quotas and persists to cache.
+     *
+     * @param tenantId - Tenant identifier
+     * @param quotas - Partial quotas to update
+     */
+    setQuota(tenantId: string, quotas: Partial<TenantQuotas>): Promise<void>;
+    /**
+     * Get quota configuration for a tenant.
+     * Returns defaults if no custom quotas set.
+     *
+     * @param tenantId - Tenant identifier
+     * @returns Tenant quota configuration
+     */
+    getQuota(tenantId: string): Promise<TenantQuotas>;
+    /**
+     * Get count of active slots for a resource type and tenant.
+     */
+    private getResourceCount;
+    /**
+     * Get max allowed for a resource type from quotas.
+     */
+    private getMaxForResource;
+    /**
+     * Clean up expired slots.
+     */
+    private cleanupExpiredSlots;
+    /**
+     * Stop the expiration timer (for cleanup).
+     */
+    dispose(): void;
+    /**
+     * Get current stats (for monitoring).
+     */
+    getStats(): {
+        totalSlots: number;
+        slotsByResource: Record<ResourceType, number>;
+        tenantCount: number;
+    };
+}
+
+/**
+ * @module @kb-labs/core-runtime/core/job-scheduler
+ * In-memory job scheduler with queue and execution.
+ */
+
+interface JobSchedulerConfig {
+    /** Maximum concurrent jobs globally (default: 10) */
+    maxConcurrent?: number;
+    /** Queue poll interval in ms (default: 1000) */
+    pollInterval?: number;
+    /** Default job timeout in ms (default: 300000 = 5min) */
+    defaultTimeout?: number;
+}
+/**
+ * Job handler function type.
+ */
+type JobHandler = (payload: unknown) => Promise<unknown>;
+/**
+ * In-memory job scheduler with queue processing.
+ */
+declare class JobScheduler implements IJobScheduler {
+    private resources;
+    private events;
+    private logger;
+    private jobs;
+    private queue;
+    private handlers;
+    private running;
+    private idCounter;
+    private pollTimer?;
+    private readonly config;
+    constructor(resources: IResourceManager, events: IEventBus, logger: ILogger, config?: JobSchedulerConfig);
+    /**
+     * Register a job handler for a job type.
+     */
+    registerHandler(type: string, handler: JobHandler): void;
+    /**
+     * Unregister a job handler.
+     */
+    unregisterHandler(type: string): void;
+    submit(job: JobDefinition): Promise<JobHandle>;
+    schedule(job: JobDefinition, schedule: CronExpression | Date): Promise<JobHandle>;
+    cancel(jobId: string): Promise<boolean>;
+    getStatus(jobId: string): Promise<JobHandle | null>;
+    list(filter?: JobFilter): Promise<JobHandle[]>;
+    /**
+     * Add job to queue.
+     */
+    private enqueue;
+    /**
+     * Process queued jobs.
+     */
+    private processQueue;
+    /**
+     * Execute a single job.
+     */
+    private executeJob;
+    /**
+     * Convert internal job to public handle.
+     */
+    private toHandle;
+    /**
+     * Stop the scheduler (for cleanup).
+     */
+    dispose(): void;
+    /**
+     * Get scheduler stats (for monitoring).
+     */
+    getStats(): {
+        totalJobs: number;
+        queueLength: number;
+        runningCount: number;
+        byStatus: Record<string, number>;
+    };
+}
+
+/**
+ * @module @kb-labs/core-runtime/core/cron-manager
+ * Cron job manager with scheduling support.
+ */
+
+/**
+ * In-memory cron manager with scheduling.
+ */
+declare class CronManager implements ICronManager {
+    private logger;
+    private jobs;
+    constructor(logger: ILogger);
+    register(id: string, schedule: CronExpression, handler: CronHandler): void;
+    unregister(id: string): void;
+    list(): CronJob[];
+    trigger(id: string): Promise<void>;
+    pause(id: string): void;
+    resume(id: string): void;
+    /**
+     * Schedule the next execution of a cron job.
+     */
+    private scheduleNext;
+    /**
+     * Execute a cron job.
+     */
+    private executeJob;
+    /**
+     * Stop all cron jobs (for cleanup).
+     */
+    dispose(): void;
+    /**
+     * Get stats (for monitoring).
+     */
+    getStats(): {
+        totalJobs: number;
+        activeJobs: number;
+        pausedJobs: number;
+    };
+}
+
+/**
+ * @module @kb-labs/core-runtime/core/workflow-engine
+ * In-memory workflow engine with step execution.
+ */
+
+interface WorkflowEngineConfig {
+    /** Maximum concurrent workflows globally (default: 5) */
+    maxConcurrent?: number;
+    /** Default workflow timeout in ms (default: 300000 = 5min) */
+    defaultTimeout?: number;
+}
+/**
+ * Workflow definition (registered workflows).
+ */
+interface WorkflowDefinition {
+    id: string;
+    name: string;
+    steps: WorkflowStepDefinition[];
+}
+/**
+ * Workflow step definition.
+ */
+interface WorkflowStepDefinition {
+    id: string;
+    name: string;
+    handler: (input: unknown, context: WorkflowStepContext) => Promise<unknown>;
+    continueOnError?: boolean;
+    timeout?: number;
+}
+/**
+ * Context passed to step handlers.
+ */
+interface WorkflowStepContext {
+    workflowId: string;
+    runId: string;
+    stepId: string;
+    tenantId: string;
+    previousStepOutput?: unknown;
+}
+/**
+ * In-memory workflow engine.
+ */
+declare class WorkflowEngine implements IWorkflowEngine {
+    private resources;
+    private storage;
+    private events;
+    private logger;
+    private runs;
+    private definitions;
+    private running;
+    private idCounter;
+    private readonly config;
+    constructor(resources: IResourceManager, storage: IStorage, events: IEventBus, logger: ILogger, config?: WorkflowEngineConfig);
+    /**
+     * Register a workflow definition.
+     */
+    registerWorkflow(definition: WorkflowDefinition): void;
+    /**
+     * Unregister a workflow definition.
+     */
+    unregisterWorkflow(workflowId: string): void;
+    execute(workflowId: string, input: unknown, options?: WorkflowOptions): Promise<WorkflowRun>;
+    getStatus(runId: string): Promise<WorkflowRun | null>;
+    cancel(runId: string): Promise<void>;
+    retry(runId: string, fromStep?: string): Promise<WorkflowRun>;
+    list(filter?: WorkflowFilter): Promise<WorkflowRun[]>;
+    /**
+     * Execute a single workflow step.
+     */
+    private executeStep;
+    /**
+     * Mark run as failed.
+     */
+    private failRun;
+    /**
+     * Schedule a workflow retry based on policy.
+     */
+    private scheduleRetry;
+    /**
+     * Persist workflow run to storage.
+     */
+    private persistRun;
+    /**
+     * Convert internal run to public representation.
+     */
+    private toPublicRun;
+    /**
+     * Stop all workflows (for cleanup).
+     */
+    dispose(): void;
+    /**
+     * Get engine stats (for monitoring).
+     */
+    getStats(): {
+        totalRuns: number;
+        runningCount: number;
+        registeredWorkflows: number;
+        byStatus: Record<string, number>;
+    };
+}
+
+/**
+ * @module @kb-labs/core-runtime/transport
+ * Abstract transport layer for cross-process adapter communication.
+ *
+ * Provides a transport-agnostic interface for sending adapter calls
+ * between parent and child processes. Implementations can use:
+ * - IPC (process.send/process.on('message'))
+ * - HTTP REST API
+ * - Docker exec
+ * - gRPC
+ * - WebSockets
+ *
+ * @example
+ * ```typescript
+ * import { ITransport, IPCTransport } from '@kb-labs/core-runtime/transport';
+ *
+ * const transport: ITransport = new IPCTransport();
+ * const response = await transport.send({
+ *   type: 'adapter:call',
+ *   requestId: 'uuid-123',
+ *   adapter: 'vectorStore',
+ *   method: 'search',
+ *   args: [[0.1, 0.2, 0.3], 10],
+ * });
+ * ```
+ */
+
+/**
+ * Abstract transport for sending adapter calls.
+ *
+ * Implementations must handle:
+ * - Reliable message delivery
+ * - Timeout enforcement
+ * - Error propagation
+ * - Resource cleanup
+ *
+ * Thread-safety: Implementations must be safe to call concurrently
+ * from multiple async contexts.
+ */
+interface ITransport {
+    /**
+     * Send adapter call and await response.
+     *
+     * @param call - Adapter method call to send
+     * @returns Response with result or error
+     * @throws TransportError if communication fails
+     * @throws TimeoutError if timeout exceeded
+     * @throws SerializationError if message cannot be serialized
+     *
+     * @example
+     * ```typescript
+     * const call: AdapterCall = {
+     *   type: 'adapter:call',
+     *   requestId: 'uuid-123',
+     *   adapter: 'vectorStore',
+     *   method: 'search',
+     *   args: [[0.1, 0.2, 0.3], 10],
+     *   timeout: 5000,
+     * };
+     *
+     * const response = await transport.send(call);
+     * if (response.error) {
+     *   throw deserialize(response.error);
+     * }
+     * return deserialize(response.result);
+     * ```
+     */
+    send(call: AdapterCall): Promise<AdapterResponse>;
+    /**
+     * Close transport and cleanup resources.
+     *
+     * After close():
+     * - No new calls can be sent
+     * - Pending calls are rejected with TransportError
+     * - Listeners/connections are cleaned up
+     *
+     * @example
+     * ```typescript
+     * await transport.close();
+     * // All pending calls rejected
+     * // transport.send() will throw TransportError
+     * ```
+     */
+    close(): Promise<void>;
+    /**
+     * Check if transport is closed.
+     */
+    isClosed(): boolean;
+}
+
+/**
+ * @module @kb-labs/core-runtime/proxy
+ * Generic base class for remote adapter proxies.
+ *
+ * This class provides the foundation for all IPC proxy adapters.
+ * It handles serialization, transport, and error propagation automatically.
+ *
+ * @example
+ * ```typescript
+ * import { RemoteAdapter } from '@kb-labs/core-runtime/proxy';
+ * import type { IVectorStore } from '@kb-labs/core-platform';
+ *
+ * class VectorStoreProxy extends RemoteAdapter<IVectorStore> implements IVectorStore {
+ *   constructor(transport: ITransport) {
+ *     super('vectorStore', transport);
+ *   }
+ *
+ *   async search(query: number[], limit: number): Promise<VectorSearchResult[]> {
+ *     return this.callRemote('search', [query, limit]) as Promise<VectorSearchResult[]>;
+ *   }
+ * }
+ * ```
+ */
+
+/**
+ * Generic base class for remote adapter proxies.
+ *
+ * Automatically handles:
+ * - Method call serialization
+ * - Transport communication
+ * - Response deserialization
+ * - Error propagation
+ * - Context propagation (traceId, pluginId, etc.)
+ *
+ * Type parameter T should be the adapter interface (e.g., IVectorStore).
+ */
+declare abstract class RemoteAdapter<T> {
+    private readonly adapterName;
+    private readonly transport;
+    private context?;
+    /**
+     * Create a remote adapter proxy.
+     *
+     * @param adapterName - Name of the adapter (e.g., 'vectorStore', 'cache')
+     * @param transport - Transport layer for IPC communication
+     * @param context - Optional execution context for tracing/debugging
+     */
+    constructor(adapterName: AdapterType, transport: ITransport, context?: AdapterCallContext);
+    /**
+     * Set execution context for this adapter.
+     * Context is included in all subsequent adapter calls for tracing/debugging.
+     *
+     * @param context - Execution context (traceId, pluginId, sessionId, etc.)
+     *
+     * @example
+     * ```typescript
+     * proxy.setContext({
+     *   traceId: 'trace-abc',
+     *   pluginId: '@kb-labs/mind',
+     *   sessionId: 'session-xyz',
+     * });
+     * ```
+     */
+    setContext(context: AdapterCallContext): void;
+    /**
+     * Get current execution context.
+     */
+    getContext(): AdapterCallContext | undefined;
+    /**
+     * Call a method on the remote adapter (in parent process).
+     *
+     * This method:
+     * 1. Generates a unique request ID
+     * 2. Serializes the method arguments
+     * 3. Sends the call via transport
+     * 4. Waits for response
+     * 5. Deserializes and returns the result (or throws error)
+     *
+     * @param method - Method name to call on the adapter
+     * @param args - Method arguments (will be serialized)
+     * @param timeout - Optional timeout in milliseconds (overrides transport default)
+     * @returns Promise resolving to deserialized result
+     * @throws Error if remote method throws or communication fails
+     *
+     * @example
+     * ```typescript
+     * // In VectorStoreProxy.search():
+     * return this.callRemote('search', [query, limit, filter]);
+     *
+     * // With custom timeout for bulk operations:
+     * return this.callRemote('upsert', [vectors], 120000); // 2 min timeout
+     * ```
+     */
+    protected callRemote(method: string, args: unknown[], timeout?: number): Promise<unknown>;
+    /**
+     * Get the adapter name this proxy represents.
+     */
+    protected getAdapterName(): AdapterType;
+    /**
+     * Get the transport used by this proxy.
+     * Useful for advanced use cases (e.g., checking if transport is closed).
+     */
+    protected getTransport(): ITransport;
+}
+
+/**
+ * @module @kb-labs/core-runtime/proxy
+ * IPC proxy for IVectorStore adapter.
+ *
+ * This proxy forwards all vector store operations to the parent process
+ * via IPC. The parent process owns the real QdrantVectorStore instance.
+ *
+ * Benefits:
+ * - Single QdrantVectorStore instance (shared across all sandbox workers)
+ * - Reduced memory usage (no duplicate connections)
+ * - Reduced connection count (5 instead of 250 for 50 workers)
+ *
+ * @example
+ * ```typescript
+ * import { VectorStoreProxy, createIPCTransport } from '@kb-labs/core-runtime';
+ *
+ * // In child process (sandbox worker)
+ * const transport = createIPCTransport();
+ * const vectorStore = new VectorStoreProxy(transport);
+ *
+ * // Use like normal IVectorStore
+ * const results = await vectorStore.search([0.1, 0.2, 0.3], 10);
+ * ```
+ */
+
+/**
+ * IPC proxy for IVectorStore adapter.
+ *
+ * All method calls are forwarded to the parent process via IPC.
+ * The parent process executes the call on the real vector store
+ * (e.g., QdrantVectorStore) and returns the result.
+ *
+ * From the caller's perspective, this behaves identically to a
+ * local vector store - the IPC layer is completely transparent.
+ */
+declare class VectorStoreProxy extends RemoteAdapter<IVectorStore> implements IVectorStore {
+    private static readonly BULK_OPERATION_TIMEOUT;
+    private readonly bulkTransferOptions;
+    /**
+     * Create a vector store proxy.
+     *
+     * @param transport - IPC transport to communicate with parent
+     */
+    constructor(transport: ITransport);
+    /**
+     * Search for similar vectors.
+     *
+     * @param query - Query embedding vector
+     * @param limit - Maximum number of results
+     * @param filter - Optional metadata filter
+     * @returns Promise resolving to search results
+     */
+    search(query: number[], limit: number, filter?: VectorFilter): Promise<VectorSearchResult[]>;
+    /**
+     * Insert or update vectors.
+     * Uses BulkTransfer for large payloads to avoid IPC backpressure.
+     *
+     * @param vectors - Vector records to upsert
+     */
+    upsert(vectors: VectorRecord[]): Promise<void>;
+    /**
+     * Delete vectors by IDs.
+     * Uses extended timeout for bulk deletions.
+     *
+     * @param ids - Vector IDs to delete
+     */
+    delete(ids: string[]): Promise<void>;
+    /**
+     * Upsert vectors with chunk metadata (used by Mind RAG).
+     * Uses extended timeout for bulk operations.
+     *
+     * @param scope - Scope ID
+     * @param vectors - Vector records to upsert
+     */
+    upsertChunks(scope: string, vectors: VectorRecord[]): Promise<void>;
+    /**
+     * Count total vectors in collection.
+     *
+     * @returns Promise resolving to vector count
+     */
+    count(): Promise<number>;
+    /**
+     * Get vectors by IDs.
+     * IDs argument is usually small, passed directly through IPC.
+     * Uses BulkTransfer only for large result sets.
+     *
+     * @param ids - Vector IDs to retrieve
+     * @returns Promise resolving to vector records
+     */
+    get(ids: string[]): Promise<VectorRecord[]>;
+    /**
+     * Query vectors by metadata filter.
+     * Filter argument is small, passed directly through IPC.
+     * Uses BulkTransfer only for potentially large result sets.
+     *
+     * @param filter - Metadata filter to apply
+     * @returns Promise resolving to matching vector records
+     */
+    query(filter: VectorFilter): Promise<VectorRecord[]>;
+    /**
+     * Clear all vectors from collection.
+     * Uses extended timeout for bulk deletion.
+     */
+    clear(): Promise<void>;
+    /**
+     * Initialize the vector store.
+     * Called during platform initialization.
+     */
+    initialize(): Promise<void>;
+    /**
+     * Close connections and cleanup resources.
+     */
+    close(): Promise<void>;
+}
+/**
+ * Create a VectorStore proxy with IPC transport.
+ *
+ * @param transport - IPC transport to use
+ * @returns VectorStore proxy instance
+ *
+ * @example
+ * ```typescript
+ * import { createVectorStoreProxy, createIPCTransport } from '@kb-labs/core-runtime';
+ *
+ * const transport = createIPCTransport();
+ * const vectorStore = createVectorStoreProxy(transport);
+ * ```
+ */
+declare function createVectorStoreProxy(transport: ITransport): VectorStoreProxy;
+
+/**
+ * @module @kb-labs/core-runtime/proxy
+ * IPC proxy for ICache adapter.
+ *
+ * This proxy forwards all cache operations to the parent process via IPC.
+ * The parent process owns the real cache adapter (e.g., RedisCacheAdapter).
+ *
+ * Benefits:
+ * - Single cache instance (shared across all sandbox workers)
+ * - Reduced memory usage (no duplicate Redis connections)
+ * - Reduced connection count (5 instead of 250 for 50 workers)
+ *
+ * @example
+ * ```typescript
+ * import { CacheProxy, createIPCTransport } from '@kb-labs/core-runtime';
+ *
+ * // In child process (sandbox worker)
+ * const transport = createIPCTransport();
+ * const cache = new CacheProxy(transport);
+ *
+ * // Use like normal ICache
+ * await cache.set('key', { foo: 'bar' }, 60000);
+ * const value = await cache.get('key');
+ * ```
+ */
+
+/**
+ * IPC proxy for ICache adapter.
+ *
+ * All method calls are forwarded to the parent process via IPC.
+ * The parent process executes the call on the real cache adapter
+ * (e.g., RedisCacheAdapter) and returns the result.
+ *
+ * From the caller's perspective, this behaves identically to a
+ * local cache - the IPC layer is completely transparent.
+ */
+declare class CacheProxy extends RemoteAdapter<ICache> implements ICache {
+    /**
+     * Create a cache proxy.
+     *
+     * @param transport - IPC transport to communicate with parent
+     */
+    constructor(transport: ITransport);
+    /**
+     * Get a value from cache.
+     *
+     * @param key - Cache key
+     * @returns Cached value or null if not found/expired
+     */
+    get<T>(key: string): Promise<T | null>;
+    /**
+     * Set a value in cache.
+     *
+     * @param key - Cache key
+     * @param value - Value to cache
+     * @param ttl - Time to live in milliseconds (optional)
+     */
+    set<T>(key: string, value: T, ttl?: number): Promise<void>;
+    /**
+     * Delete a value from cache.
+     *
+     * @param key - Cache key
+     */
+    delete(key: string): Promise<void>;
+    /**
+     * Clear cache entries matching a pattern.
+     *
+     * @param pattern - Glob pattern (e.g., 'user:*')
+     */
+    clear(pattern?: string): Promise<void>;
+    /**
+     * Add member to sorted set with score.
+     *
+     * @param key - Sorted set key
+     * @param score - Numeric score (typically timestamp)
+     * @param member - Member to add
+     */
+    zadd(key: string, score: number, member: string): Promise<void>;
+    /**
+     * Get members from sorted set by score range.
+     *
+     * @param key - Sorted set key
+     * @param min - Minimum score (inclusive)
+     * @param max - Maximum score (inclusive)
+     * @returns Array of members in score order
+     */
+    zrangebyscore(key: string, min: number, max: number): Promise<string[]>;
+    /**
+     * Remove member from sorted set.
+     *
+     * @param key - Sorted set key
+     * @param member - Member to remove
+     */
+    zrem(key: string, member: string): Promise<void>;
+    /**
+     * Set key-value pair only if key does not exist (atomic operation).
+     *
+     * @param key - Cache key
+     * @param value - Value to set
+     * @param ttl - Time to live in milliseconds (optional)
+     * @returns true if value was set, false if key already exists
+     */
+    setIfNotExists<T>(key: string, value: T, ttl?: number): Promise<boolean>;
+}
+/**
+ * Create a Cache proxy with IPC transport.
+ *
+ * @param transport - IPC transport to use
+ * @returns Cache proxy instance
+ *
+ * @example
+ * ```typescript
+ * import { createCacheProxy, createIPCTransport } from '@kb-labs/core-runtime';
+ *
+ * const transport = createIPCTransport();
+ * const cache = createCacheProxy(transport);
+ * ```
+ */
+declare function createCacheProxy(transport: ITransport): CacheProxy;
+
+/**
+ * @module @kb-labs/core-runtime/proxy
+ * IPC proxy for ILLM adapter.
+ *
+ * This proxy forwards all LLM operations to the parent process via IPC.
+ * The parent process owns the real LLM adapter (e.g., OpenAILLM).
+ *
+ * Benefits:
+ * - Single LLM instance (shared rate limiter across all workers)
+ * - Reduced memory usage (no duplicate API clients)
+ * - Centralized quota enforcement (tenant rate limits)
+ *
+ * Note: true token-by-token streaming is not supported over IPC.
+ * This proxy falls back to complete() and emits a single chunk.
+ *
+ * @example
+ * ```typescript
+ * import { LLMProxy, createIPCTransport } from '@kb-labs/core-runtime';
+ *
+ * // In child process (sandbox worker)
+ * const transport = createIPCTransport();
+ * const llm = new LLMProxy(transport);
+ *
+ * // Use like normal ILLM
+ * const response = await llm.complete('What is TypeScript?', {
+ *   model: 'gpt-4',
+ *   temperature: 0.7,
+ *   maxTokens: 500,
+ * });
+ * ```
+ */
+
+/**
+ * IPC proxy for ILLM adapter.
+ *
+ * All method calls are forwarded to the parent process via IPC.
+ * The parent process executes the call on the real LLM adapter
+ * (e.g., OpenAILLM) and returns the result.
+ *
+ * **Limitation**: true token-by-token `stream()` is not supported over IPC.
+ * Streaming requires bidirectional communication which is not
+ * currently implemented. This proxy falls back to `complete()`.
+ */
+declare class LLMProxy extends RemoteAdapter<ILLM> implements ILLM {
+    /**
+     * Create an LLM proxy.
+     *
+     * @param transport - IPC transport to communicate with parent
+     */
+    constructor(transport: ITransport);
+    /**
+     * Generate a completion for the given prompt.
+     *
+     * @param prompt - Text prompt
+     * @param options - Optional generation options
+     * @returns LLM response with content and token usage
+     */
+    complete(prompt: string, options?: LLMOptions): Promise<LLMResponse>;
+    getProtocolCapabilities(): LLMProtocolCapabilities;
+    /**
+     * Stream a completion for the given prompt.
+     *
+     * **Fallback over IPC**: Uses complete() and emits a single chunk.
+     *
+     * Streaming requires bidirectional communication which is not
+     * currently implemented in the IPC protocol. This fallback preserves
+     * API compatibility for callers expecting AsyncIterable<string>.
+     *
+     * @param prompt - Text prompt
+     * @param options - Optional generation options
+     * @returns Async iterable with a single chunk from complete()
+     */
+    stream(prompt: string, options?: LLMOptions): AsyncIterable<string>;
+    /**
+     * Chat with native tool calling support.
+     *
+     * Forwards tool calling request to parent process via IPC.
+     *
+     * @param messages - Conversation history
+     * @param options - Options including tools and tool choice
+     * @returns LLM response with optional tool calls
+     */
+    chatWithTools(messages: LLMMessage[], options: LLMToolCallOptions): Promise<LLMToolCallResponse>;
+}
+
+/**
+ * @module @kb-labs/core-runtime/proxy
+ * IPC proxy for IEmbeddings adapter.
+ *
+ * This proxy forwards all embeddings operations to the parent process via IPC.
+ * The parent process owns the real embeddings adapter (e.g., OpenAIEmbeddings).
+ *
+ * Benefits:
+ * - Single embeddings instance (shared rate limiter across all workers)
+ * - Reduced memory usage (no duplicate API clients)
+ * - Centralized quota enforcement (tenant rate limits)
+ *
+ * @example
+ * ```typescript
+ * import { EmbeddingsProxy, createIPCTransport } from '@kb-labs/core-runtime';
+ *
+ * // In child process (sandbox worker)
+ * const transport = createIPCTransport();
+ * const embeddings = new EmbeddingsProxy(transport);
+ *
+ * // Use like normal IEmbeddings
+ * const vector = await embeddings.embed('Hello world');
+ * const vectors = await embeddings.embedBatch(['foo', 'bar', 'baz']);
+ * console.log('Dimensions:', embeddings.dimensions); // 1536
+ * ```
+ */
+
+/**
+ * IPC proxy for IEmbeddings adapter.
+ *
+ * All method calls are forwarded to the parent process via IPC.
+ * The parent process executes the call on the real embeddings adapter
+ * (e.g., OpenAIEmbeddings) and returns the result.
+ *
+ * The `dimensions` property is fetched once during initialization
+ * and cached locally for performance.
+ */
+declare class EmbeddingsProxy extends RemoteAdapter<IEmbeddings> implements IEmbeddings {
+    private _dimensions?;
+    /**
+     * Create an embeddings proxy.
+     *
+     * @param transport - IPC transport to communicate with parent
+     * @param dimensions - Optional dimensions override (avoids IPC call)
+     */
+    constructor(transport: ITransport, dimensions?: number);
+    /**
+     * Generate embedding vector for a single text.
+     *
+     * @param text - Input text
+     * @returns Embedding vector
+     */
+    embed(text: string): Promise<number[]>;
+    /**
+     * Generate embedding vectors for multiple texts.
+     *
+     * @param texts - Array of input texts
+     * @returns Array of embedding vectors (same order as input)
+     */
+    embedBatch(texts: string[]): Promise<number[][]>;
+    /**
+     * Dimension of the embedding vectors.
+     *
+     * This value is fetched once from the parent on first access
+     * and cached locally for performance.
+     */
+    get dimensions(): number;
+    /**
+     * Initialize dimensions by fetching from parent.
+     *
+     * This is called automatically by initPlatform() in child process.
+     * If you create EmbeddingsProxy manually, call this method before
+     * accessing the `dimensions` property.
+     *
+     * @returns Dimensions value
+     *
+     * @example
+     * ```typescript
+     * const proxy = new EmbeddingsProxy(transport);
+     * await proxy.getDimensions(); // Fetch once
+     * console.log(proxy.dimensions); // Now safe to access
+     * ```
+     */
+    getDimensions(): Promise<number>;
+}
+
+/**
+ * @module @kb-labs/core-runtime/proxy
+ * IPC proxy for IStorage adapter.
+ *
+ * This proxy forwards all storage operations to the parent process via IPC.
+ * The parent process owns the real storage adapter (e.g., FilesystemStorageAdapter).
+ *
+ * Benefits:
+ * - Single storage instance (consistent file access across all workers)
+ * - Reduced memory usage (no duplicate file handles)
+ * - No race conditions (centralized file access)
+ *
+ * Note: Buffer serialization is handled automatically by the IPC layer.
+ *
+ * @example
+ * ```typescript
+ * import { StorageProxy, createIPCTransport } from '@kb-labs/core-runtime';
+ *
+ * // In child process (sandbox worker)
+ * const transport = createIPCTransport();
+ * const storage = new StorageProxy(transport);
+ *
+ * // Use like normal IStorage
+ * await storage.write('.kb/data.json', Buffer.from('{"foo":"bar"}'));
+ * const data = await storage.read('.kb/data.json');
+ * const files = await storage.list('.kb/');
+ * ```
+ */
+
+/**
+ * IPC proxy for IStorage adapter.
+ *
+ * All method calls are forwarded to the parent process via IPC.
+ * The parent process executes the call on the real storage adapter
+ * (e.g., FilesystemStorageAdapter) and returns the result.
+ *
+ * Buffer serialization/deserialization is handled automatically
+ * by the IPC serializer (Buffer → base64 → Buffer).
+ */
+declare class StorageProxy extends RemoteAdapter<IStorage$1> implements IStorage$1 {
+    /**
+     * Create a storage proxy.
+     *
+     * @param transport - IPC transport to communicate with parent
+     */
+    constructor(transport: ITransport);
+    /**
+     * Read file contents.
+     *
+     * @param path - File path
+     * @returns File contents or null if not found
+     */
+    read(path: string): Promise<Buffer | null>;
+    /**
+     * Write file contents.
+     *
+     * @param path - File path
+     * @param data - File contents
+     */
+    write(path: string, data: Buffer): Promise<void>;
+    /**
+     * Delete a file.
+     *
+     * @param path - File path
+     */
+    delete(path: string): Promise<void>;
+    /**
+     * List files matching a prefix.
+     *
+     * @param prefix - Path prefix (e.g., 'docs/')
+     * @returns Array of file paths
+     */
+    list(prefix: string): Promise<string[]>;
+    /**
+     * Check if a file exists.
+     *
+     * @param path - File path
+     * @returns True if file exists, false otherwise
+     */
+    exists(path: string): Promise<boolean>;
+    /**
+     * Get file metadata.
+     * Optional method - implements IStorage.stat().
+     *
+     * @param path - File path
+     * @returns File metadata or null if not found
+     */
+    stat?(path: string): Promise<StorageMetadata | null>;
+    /**
+     * Copy file within storage.
+     * Optional method - implements IStorage.copy().
+     *
+     * @param sourcePath - Source file path
+     * @param destPath - Destination file path
+     */
+    copy?(sourcePath: string, destPath: string): Promise<void>;
+    /**
+     * Move file within storage.
+     * Optional method - implements IStorage.move().
+     *
+     * @param sourcePath - Source file path
+     * @param destPath - Destination file path
+     */
+    move?(sourcePath: string, destPath: string): Promise<void>;
+    /**
+     * List files with metadata.
+     * Optional method - implements IStorage.listWithMetadata().
+     *
+     * @param prefix - Path prefix (e.g., 'docs/')
+     * @returns Array of file metadata
+     */
+    listWithMetadata?(prefix: string): Promise<StorageMetadata[]>;
+}
+/**
+ * Create a Storage proxy with IPC transport.
+ *
+ * @param transport - IPC transport to use
+ * @returns Storage proxy instance
+ *
+ * @example
+ * ```typescript
+ * import { createStorageProxy, createIPCTransport } from '@kb-labs/core-runtime';
+ *
+ * const transport = createIPCTransport();
+ * const storage = createStorageProxy(transport);
+ * ```
+ */
+declare function createStorageProxy(transport: ITransport): StorageProxy;
+
+/**
+ * @module @kb-labs/core-runtime/proxy
+ * IPC proxy for ISQLDatabase adapter.
+ *
+ * This proxy forwards all SQL database operations to the parent process via IPC.
+ * The parent process owns the real SQL adapter (e.g., SQLiteAdapter).
+ *
+ * Benefits:
+ * - Single database connection (consistent data access across all workers)
+ * - Reduced memory usage (no duplicate connections)
+ * - No race conditions (centralized transaction management)
+ *
+ * @example
+ * ```typescript
+ * import { SQLDatabaseProxy, createIPCTransport } from '@kb-labs/core-runtime';
+ *
+ * // In child process (sandbox worker)
+ * const transport = createIPCTransport();
+ * const db = new SQLDatabaseProxy(transport);
+ *
+ * // Use like normal ISQLDatabase
+ * const result = await db.query('SELECT * FROM users WHERE id = ?', [123]);
+ * console.log(result.rows);
+ *
+ * // Transactions
+ * const tx = await db.transaction();
+ * await tx.query('INSERT INTO users (name) VALUES (?)', ['Alice']);
+ * await tx.commit();
+ * ```
+ */
+
+/**
+ * IPC proxy for ISQLDatabase adapter.
+ *
+ * All method calls are forwarded to the parent process via IPC.
+ * The parent process executes the call on the real SQL adapter
+ * (e.g., SQLiteAdapter, PostgreSQLAdapter) and returns the result.
+ */
+declare class SQLDatabaseProxy extends RemoteAdapter<ISQLDatabase> implements ISQLDatabase {
+    /**
+     * Create a SQL database proxy.
+     *
+     * @param transport - IPC transport to communicate with parent
+     */
+    constructor(transport: ITransport);
+    /**
+     * Execute a SQL query.
+     *
+     * @param sql - SQL query string
+     * @param params - Query parameters
+     * @returns Query result
+     */
+    query<T = unknown>(sql: string, params?: unknown[]): Promise<SQLQueryResult<T>>;
+    /**
+     * Begin a SQL transaction.
+     *
+     * @returns Transaction proxy object
+     */
+    transaction(): Promise<SQLTransaction>;
+    /**
+     * Close the database connection.
+     */
+    close(): Promise<void>;
+}
+/**
+ * Create a SQL database proxy with IPC transport.
+ *
+ * @param transport - IPC transport to use
+ * @returns SQL database proxy instance
+ *
+ * @example
+ * ```typescript
+ * import { createSQLDatabaseProxy, createIPCTransport } from '@kb-labs/core-runtime';
+ *
+ * const transport = createIPCTransport();
+ * const db = createSQLDatabaseProxy(transport);
+ * ```
+ */
+declare function createSQLDatabaseProxy(transport: ITransport): SQLDatabaseProxy;
+
+/**
+ * @module @kb-labs/core-runtime/proxy
+ * IPC proxy for IDocumentDatabase adapter.
+ *
+ * This proxy forwards all document database operations to the parent process via IPC.
+ * The parent process owns the real document adapter (e.g., MongoDBAdapter).
+ *
+ * Benefits:
+ * - Single database connection (consistent data access across all workers)
+ * - Reduced memory usage (no duplicate connections)
+ * - No race conditions (centralized transaction management)
+ *
+ * @example
+ * ```typescript
+ * import { DocumentDatabaseProxy, createIPCTransport } from '@kb-labs/core-runtime';
+ *
+ * // In child process (sandbox worker)
+ * const transport = createIPCTransport();
+ * const db = new DocumentDatabaseProxy(transport);
+ *
+ * // Use like normal IDocumentDatabase
+ * const users = await db.find('users', { age: { $gt: 18 } }, { limit: 10 });
+ * console.log(users);
+ *
+ * // Update by ID
+ * const updated = await db.updateById('users', '123', { $set: { active: true } });
+ * ```
+ */
+
+/**
+ * IPC proxy for IDocumentDatabase adapter.
+ *
+ * All method calls are forwarded to the parent process via IPC.
+ * The parent process executes the call on the real document adapter
+ * (e.g., MongoDBAdapter) and returns the result.
+ */
+declare class DocumentDatabaseProxy extends RemoteAdapter<IDocumentDatabase> implements IDocumentDatabase {
+    /**
+     * Create a document database proxy.
+     *
+     * @param transport - IPC transport to communicate with parent
+     */
+    constructor(transport: ITransport);
+    /**
+     * Find documents matching a filter.
+     *
+     * @param collection - Collection name
+     * @param filter - Query filter
+     * @param options - Find options (limit, skip, sort)
+     * @returns Array of matching documents
+     */
+    find<T extends BaseDocument>(collection: string, filter: DocumentFilter<T>, options?: FindOptions): Promise<T[]>;
+    /**
+     * Find a single document by ID.
+     *
+     * @param collection - Collection name
+     * @param id - Document ID
+     * @returns Document or null if not found
+     */
+    findById<T extends BaseDocument>(collection: string, id: string): Promise<T | null>;
+    /**
+     * Insert a single document.
+     *
+     * @param collection - Collection name
+     * @param document - Document to insert (id, createdAt, updatedAt will be added)
+     * @returns Inserted document with generated fields
+     */
+    insertOne<T extends BaseDocument>(collection: string, document: Omit<T, 'id' | 'createdAt' | 'updatedAt'>): Promise<T>;
+    /**
+     * Update documents matching a filter.
+     *
+     * @param collection - Collection name
+     * @param filter - Query filter
+     * @param update - Update operations
+     * @returns Number of documents updated
+     */
+    updateMany<T extends BaseDocument>(collection: string, filter: DocumentFilter<T>, update: DocumentUpdate<T>): Promise<number>;
+    /**
+     * Update a single document by ID.
+     *
+     * @param collection - Collection name
+     * @param id - Document ID
+     * @param update - Update operations
+     * @returns Updated document or null if not found
+     */
+    updateById<T extends BaseDocument>(collection: string, id: string, update: DocumentUpdate<T>): Promise<T | null>;
+    /**
+     * Delete documents matching a filter.
+     *
+     * @param collection - Collection name
+     * @param filter - Query filter
+     * @returns Number of documents deleted
+     */
+    deleteMany<T extends BaseDocument>(collection: string, filter: DocumentFilter<T>): Promise<number>;
+    /**
+     * Delete a single document by ID.
+     *
+     * @param collection - Collection name
+     * @param id - Document ID
+     * @returns True if deleted, false if not found
+     */
+    deleteById(collection: string, id: string): Promise<boolean>;
+    /**
+     * Count documents matching a filter.
+     *
+     * @param collection - Collection name
+     * @param filter - Query filter
+     * @returns Number of matching documents
+     */
+    count<T extends BaseDocument>(collection: string, filter: DocumentFilter<T>): Promise<number>;
+    /**
+     * Close the database connection.
+     */
+    close(): Promise<void>;
+}
+/**
+ * Create a document database proxy with IPC transport.
+ *
+ * @param transport - IPC transport to use
+ * @returns Document database proxy instance
+ *
+ * @example
+ * ```typescript
+ * import { createDocumentDatabaseProxy, createIPCTransport } from '@kb-labs/core-runtime';
+ *
+ * const transport = createIPCTransport();
+ * const db = createDocumentDatabaseProxy(transport);
+ * ```
+ */
+declare function createDocumentDatabaseProxy(transport: ITransport): DocumentDatabaseProxy;
+
+/**
+ * @module @kb-labs/core-runtime/proxy/create-proxy-platform
+ * Create platform container with proxy adapters for subprocess execution.
+ *
+ * This function creates a PlatformContainer where all adapters are proxies
+ * that forward calls to the parent process via IPC (Unix socket).
+ *
+ * Used in subprocess workers to access real platform services from parent.
+ */
+
+interface CreateProxyPlatformOptions {
+    /**
+     * Path to Unix socket for IPC communication.
+     * Should match the socket path used by UnixSocketServer in parent process.
+     * Default: /tmp/kb-ipc.sock
+     */
+    socketPath?: string;
+    /**
+     * Logger for subprocess (can be noop or local file logger).
+     * Note: This logger is NOT proxied - logs are local to subprocess.
+     */
+    logger?: ILogger;
+    /**
+     * Custom transport (for testing).
+     * If not provided, UnixSocketTransport will be created.
+     */
+    transport?: ITransport;
+}
+/**
+ * Create platform container with proxy adapters.
+ *
+ * All adapters (except logger) forward calls to parent process via IPC.
+ * This allows subprocess handlers to access real platform services.
+ *
+ * @param options - Configuration options
+ * @returns Platform container with proxy adapters
+ *
+ * @example
+ * ```typescript
+ * // In subprocess (worker-script.ts)
+ * import { createProxyPlatform } from '@kb-labs/core-runtime/proxy';
+ *
+ * const platform = await createProxyPlatform({
+ *   socketPath: process.env.KB_IPC_SOCKET_PATH,
+ *   logger: createFileLogger('/tmp/worker.log'),
+ * });
+ *
+ * // Now handlers can use real platform services
+ * await platform.cache.set('key', 'value');
+ * const result = await platform.llm.complete({ prompt: 'Hello' });
+ * ```
+ */
+declare function createProxyPlatform(options?: CreateProxyPlatformOptions): Promise<PlatformContainer>;
+/**
+ * Close proxy platform and disconnect from parent.
+ *
+ * Should be called when subprocess is shutting down.
+ *
+ * @param platform - Platform container created by createProxyPlatform()
+ *
+ * @example
+ * ```typescript
+ * const platform = await createProxyPlatform();
+ * // ... use platform ...
+ * await closeProxyPlatform(platform);
+ * ```
+ */
+declare function closeProxyPlatform(platform: PlatformContainer): Promise<void>;
+
+interface MonitoringSnapshot {
+    resource: ResourceType;
+    availability?: ResourceAvailability;
+    quota?: TenantQuotas;
+    tenantId?: string;
+    ts: string;
+}
+interface MonitoringOptions {
+    resources?: ResourceType[];
+    tenantId?: string;
+}
+declare function getMonitoringSnapshot(options?: MonitoringOptions): Promise<MonitoringSnapshot[]>;
+type DegradedLevel = 'normal' | 'degraded' | 'critical';
+interface DegradedStatus {
+    level: DegradedLevel;
+    ts: string;
+    reason?: string;
+}
+interface DegradedOptions extends MonitoringOptions {
+    thresholds?: {
+        degraded?: number;
+        critical?: number;
+    };
+}
+declare function getDegradedStatus(options?: DegradedOptions): Promise<DegradedStatus>;
+
+/**
+ * @module @kb-labs/core-runtime/use-cases/start-full-cycle
+ * Unified one-click full-cycle entrypoint.
+ */
+
+/**
+ * Start full-cycle run through configured run orchestrator.
+ */
+declare function startFullCycle(platform: Pick<PlatformContainer, 'runOrchestrator'>, request: StartFullCycleRequest): Promise<RunRecord>;
+
+export { type AdapterTypes, type AdaptersConfig, CacheProxy, type CoreAdapterTypes, type CoreFeaturesConfig, type CreateProxyPlatformOptions, CronManager, type DegradedLevel, type DegradedOptions, type DegradedStatus, type DiscoveredAdapter, DocumentDatabaseProxy, EmbeddingsProxy, EnvironmentManager, type ExecutionConfig, type JobHandler, JobScheduler, type JobSchedulerConfig, type JobsConfig, LLMProxy, type MonitoringOptions, type MonitoringSnapshot, type PlatformConfig, PlatformContainer, type PlatformLifecycleContext, type PlatformLifecycleHooks, type PlatformLifecyclePhase, RemoteAdapter, type ResourceBrokerConfig, ResourceManager, type ResourceManagerConfig, type ResourcesConfig, RunExecutor, RunOrchestrator, type RunStepExecutionRequest, SQLDatabaseProxy, SnapshotManager, type StartFullCycleRequest, StorageProxy, VectorStoreProxy, type WorkflowDefinition, WorkflowEngine, type WorkflowEngineConfig, type WorkflowStepContext, type WorkflowStepDefinition, type WorkflowsConfig, WorkspaceManager, closeProxyPlatform, createAnalyticsContext, createCacheProxy, createDocumentDatabaseProxy, createProxyPlatform, createSQLDatabaseProxy, createStorageProxy, createVectorStoreProxy, discoverAdapters, getDegradedStatus, getMonitoringSnapshot, initPlatform, platform, resetPlatform, resolveAdapter, startFullCycle };