@kb-labs/mcp-app 2.117.0 → 2.118.1

package/dist/bin.cjs

@@ -3590,6 +3590,52 @@ function createSocketPath(id) {
   }
   return `/tmp/kb-${id}.sock`;
 }
+function createDocumentDatabaseProxy(transport) {
+  return new DocumentDatabaseProxy(transport);
+}
+function createKVStoreProxy(transport) {
+  return new KVStoreProxy(transport);
+}
+function createCacheProxy(transport) {
+  return new CacheProxy(transport);
+}
+function createConfigProxy(transport) {
+  return new ConfigProxy(transport);
+}
+function createVectorStoreProxy(transport) {
+  return new VectorStoreProxy(transport);
+}
+function createInvokeProxy(transport) {
+  return new InvokeProxy(transport);
+}
+function defineIPCOperations() {
+  return (operations) => operations;
+}
+function createIPCAdapterRoutes() {
+  const routes = {};
+  for (const slot of Object.keys(platformAdapterTransportPolicy)) {
+    const policy = platformAdapterTransportPolicy[slot];
+    if (!("adapter" in policy)) {
+      continue;
+    }
+    if (routes[policy.adapter] !== void 0) {
+      throw new Error(`Duplicate IPC adapter route '${policy.adapter}'`);
+    }
+    routes[policy.adapter] = slot;
+  }
+  return Object.freeze(routes);
+}
+function resolveIPCAdapter(platform2, adapterType) {
+  const slot = IPC_ADAPTER_ROUTES[adapterType];
+  if (!slot) {
+    throw new Error(`Adapter '${adapterType}' is not exposed over IPC`);
+  }
+  const adapter = platform2[slot];
+  if (adapter === void 0) {
+    throw new Error(`Adapter '${adapterType}' is not configured for IPC`);
+  }
+  return adapter;
+}
 function toSerializableError(error2) {
   const serialized = serialize(error2);
   if (serialized && typeof serialized === "object" && "__type" in serialized && serialized.__type === "Error") {
@@ -3650,14 +3696,14 @@ function createProxyPlatform(options) {
   const { transport } = options;
   const logger2 = options.logger ?? new LoggerProxy(transport);
   const processExecutor = new ProcessExecutorProxy(transport);
-  const cache = new CacheProxy(transport);
+  const cache = platformAdapterTransportPolicy.cache.proxy(transport);
   const llm = new LLMProxy(transport);
   const embeddings = new EmbeddingsProxy(transport);
-  const vectorStore = new VectorStoreProxy(transport);
+  const vectorStore = platformAdapterTransportPolicy.vectorStore.proxy(transport);
   const storage = new StorageProxy(transport);
-  const documentDatabase = new DocumentDatabaseProxy(transport);
-  const kvStore = new KVStoreProxy(transport);
-  const config2 = new ConfigProxy(transport);
+  const documentDatabase = platformAdapterTransportPolicy.documentDatabase.proxy(transport);
+  const kvStore = platformAdapterTransportPolicy.kvStore.proxy(transport);
+  const config2 = platformAdapterTransportPolicy.config.proxy(transport);
   const eventBus = new EventBusProxy(transport);
   const analytics = {
     track: async () => {
@@ -3667,10 +3713,7 @@ function createProxyPlatform(options) {
     flush: async () => {
     }
   };
-  const invoke = {
-    call: async () => ({ success: false, error: "Invoke not available in proxy context" }),
-    isAvailable: async () => false
-  };
+  const invoke = platformAdapterTransportPolicy.invoke.proxy(transport);
   const logs = {
     query: async () => ({ logs: [], total: 0, hasMore: false, source: "buffer" }),
     getById: async () => null,
@@ -3697,7 +3740,7 @@ function createProxyPlatform(options) {
     processExecutor
   };
 }
-var BulkTransferHelper, DEFAULT_SOCKET_PATH, UnixSocketServer, IPCServer, ChildIPCServer, TransportError, TimeoutError, CircuitOpenError, OPERATION_TIMEOUTS, IPCTransport, UnixSocketTransport, RemoteAdapter, CacheProxy, LLMProxy, EmbeddingsProxy, VectorStoreProxy, StorageProxy, DocumentDatabaseProxy, stripSignal, KVStoreProxy, stripSignal2, ConfigProxy, EventBusProxy, LoggerProxy, PROCESS_RPC_GRACE_MS, CONTROL_RPC_TIMEOUT_MS, MAX_TIMER_MS, ProcessExecutorProxy;
+var BulkTransferHelper, DEFAULT_SOCKET_PATH, RemoteAdapter, DocumentDatabaseProxy, stripSignal, KVStoreProxy, stripSignal2, CacheProxy, ConfigProxy, VectorStoreProxy, InvokeProxy, documentDatabaseIPCOperations, kvStoreIPCOperations, cacheIPCOperations, configIPCOperations, vectorStoreIPCOperations, invokeIPCOperations, platformAdapterTransportPolicy, IPC_ADAPTER_ROUTES, UnixSocketServer, IPCServer, ChildIPCServer, TransportError, TimeoutError, CircuitOpenError, OPERATION_TIMEOUTS, IPCTransport, UnixSocketTransport, LLMProxy, EmbeddingsProxy, StorageProxy, EventBusProxy, LoggerProxy, PROCESS_RPC_GRACE_MS, CONTROL_RPC_TIMEOUT_MS, MAX_TIMER_MS, ProcessExecutorProxy;
 var init_dist5 = __esm({
   "../../../core/ipc/dist/index.js"() {
     init_serializable();
@@ -3814,300 +3857,881 @@ var init_dist5 = __esm({
       }
     });
     DEFAULT_SOCKET_PATH = createSocketPath(`ipc-${process.pid}`);
-    UnixSocketServer = class {
+    RemoteAdapter = class {
       /**
-       * Create a Unix Socket server.
+       * Create a remote adapter proxy.
        *
-       * @param platform - Platform container with real adapters
-       * @param config - Server configuration
-       */
-      constructor(platform2, config2 = {}) {
-        this.platform = platform2;
-        this.socketPath = config2.socketPath ?? DEFAULT_SOCKET_PATH;
-        this.authToken = config2.authToken;
-      }
-      platform;
-      server = null;
-      clients = /* @__PURE__ */ new Set();
-      socketPath;
-      authToken;
-      started = false;
-      /**
-       * Get the socket path.
-       * Used by parent process to pass to child processes via env var.
+       * @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
        */
-      getSocketPath() {
-        return this.socketPath;
+      constructor(adapterName, transport, context) {
+        this.adapterName = adapterName;
+        this.transport = transport;
+        this.context = context;
       }
+      adapterName;
+      transport;
+      context;
       /**
-       * Start listening for connections.
+       * 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',
+       * });
+       * ```
        */
-      async start() {
-        BulkTransferHelper.registerSignalHandlers();
-        if (fs5__namespace.existsSync(this.socketPath)) {
-          fs5__namespace.unlinkSync(this.socketPath);
-        }
-        return new Promise((resolve9, reject) => {
-          this.server = net__namespace.createServer((socket) => {
-            this.handleClient(socket);
-          });
-          this.server.on("error", (error2) => {
-            reject(error2);
-          });
-          this.server.listen(this.socketPath, () => {
-            fs5__namespace.chmodSync(this.socketPath, 438);
-            this.started = true;
-            this.platform.logger.debug("UnixSocketServer started listening for adapter calls");
-            resolve9();
-          });
-        });
+      setContext(context) {
+        this.context = context;
       }
       /**
-       * Handle new client connection.
+       * Get current execution context.
        */
-      handleClient(socket) {
-        this.clients.add(socket);
-        let buffer = "";
-        socket.on("data", (data) => {
-          buffer += data.toString("utf8");
-          let newlineIndex;
-          while ((newlineIndex = buffer.indexOf("\n")) !== -1) {
-            const line = buffer.slice(0, newlineIndex);
-            buffer = buffer.slice(newlineIndex + 1);
-            if (line.trim().length === 0) {
-              continue;
-            }
-            try {
-              const call = JSON.parse(line);
-              this.handleCall(socket, call);
-            } catch (error2) {
-              this.platform.logger.warn("UnixSocketServer: failed to parse message", { error: error2 });
-            }
-          }
-        });
-        socket.on("close", () => {
-          this.clients.delete(socket);
-        });
-        socket.on("error", (error2) => {
-          this.platform.logger.warn("UnixSocketServer: client socket error", { error: error2 });
-          this.clients.delete(socket);
-        });
+      getContext() {
+        return this.context;
       }
       /**
-       * Handle adapter call from client.
+       * 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
+       * ```
        */
-      async handleCall(socket, call) {
-        const callAuthToken = call.context?.authToken;
-        if (this.authToken && callAuthToken !== this.authToken) {
-          const response = {
-            type: "adapter:response",
-            requestId: call.requestId,
-            error: toSerializableError(new Error("Unauthorized IPC call: invalid auth token"))
-          };
-          socket.write(JSON.stringify(response) + "\n", "utf8");
-          return;
-        }
-        if (call.version !== IPC_PROTOCOL_VERSION) {
-          this.platform.logger.warn("UnixSocketServer: protocol version mismatch", {
-            received: call.version,
-            expected: IPC_PROTOCOL_VERSION,
-            adapter: call.adapter,
-            method: call.method,
-            note: "Child process may be using outdated protocol. Consider rebuilding."
-          });
+      async callRemote(method, args, timeout) {
+        const requestId = crypto4.randomUUID();
+        const call = {
+          version: IPC_PROTOCOL_VERSION,
+          // Protocol version for backward compatibility
+          type: "adapter:call",
+          requestId,
+          adapter: this.adapterName,
+          method,
+          args: args.map((arg) => serialize(arg)),
+          timeout,
+          // Optional timeout for this specific call
+          context: this.context
+          // Include execution context for tracing/debugging
+        };
+        const response = await this.transport.send(call);
+        if (response.error) {
+          throw deserialize(response.error);
         }
-        if (call.context) {
-          this.platform.logger.debug("UnixSocketServer: adapter call", {
-            version: call.version,
-            traceId: call.context.traceId,
-            pluginId: call.context.pluginId,
-            sessionId: call.context.sessionId,
-            tenantId: call.context.tenantId,
-            adapter: call.adapter,
-            method: call.method
-          });
+        if (response.result === void 0) {
+          return void 0;
         }
-        try {
-          const adapter = this.getAdapter(call.adapter);
-          if (adapter === null || typeof adapter !== "object" && typeof adapter !== "function") {
-            throw new Error(`Adapter '${call.adapter}' is not callable`);
-          }
-          const method = Reflect.get(adapter, call.method);
-          if (typeof method !== "function") {
-            throw new Error(
-              `Method '${call.method}' not found on adapter '${call.adapter}'. Available methods: ${Object.getOwnPropertyNames(Object.getPrototypeOf(adapter)).join(", ")}`
-            );
-          }
-          const args = await Promise.all(
-            call.args.map(async (arg) => {
-              const deserialized = deserialize(arg);
-              if (BulkTransferHelper.isBulkTransfer(deserialized)) {
-                return BulkTransferHelper.deserialize(deserialized);
-              }
-              return deserialized;
-            })
-          );
-          const result = await method.apply(adapter, args);
-          let serializedResult;
-          if (result !== void 0 && result !== null && typeof result === "object") {
-            const resultJson = JSON.stringify(result);
-            if (resultJson.length > 1e6) {
-              const transfer = await BulkTransferHelper.serialize(result, {
-                maxInlineSize: 1e6,
-                tempDir: process.env.KB_TEMP_DIR ?? os4__namespace.tmpdir()
-              });
-              serializedResult = serialize(transfer);
-            } else {
-              serializedResult = serialize(result);
-            }
-          } else {
-            serializedResult = serialize(result);
-          }
-          const response = {
-            type: "adapter:response",
-            requestId: call.requestId,
-            result: serializedResult
-          };
-          const message2 = JSON.stringify(response) + "\n";
-          socket.write(message2, "utf8");
-        } catch (error2) {
-          const response = {
-            type: "adapter:response",
-            requestId: call.requestId,
-            error: toSerializableError(error2)
-          };
-          const message2 = JSON.stringify(response) + "\n";
-          socket.write(message2, "utf8");
-          const cause = error2 instanceof Error ? error2.message : String(error2);
-          this.platform.logger.error(
-            `UnixSocketServer: ${call.adapter}.${call.method} failed \u2014 ${cause}`,
-            error2 instanceof Error ? error2 : new Error(String(error2)),
-            { adapter: call.adapter, method: call.method }
-          );
+        const result = deserialize(response.result);
+        if (BulkTransferHelper.isBulkTransfer(result)) {
+          return BulkTransferHelper.deserialize(result);
         }
+        return result;
       }
       /**
-       * Get adapter instance from platform container.
-       *
-       * @param name - Adapter name (e.g., 'vectorStore', 'cache')
-       * @returns Adapter instance
-       * @throws Error if adapter not found
+       * Get the adapter name this proxy represents.
        */
-      getAdapter(name) {
-        switch (name) {
-          case "vectorStore":
-            return this.platform.vectorStore;
-          case "cache":
-            return this.platform.cache;
-          case "config":
-            return this.platform.config;
-          case "llm":
-            return this.platform.llm;
-          case "embeddings":
-            return this.platform.embeddings;
-          case "storage":
-            return this.platform.storage;
-          case "logger":
-            return this.platform.logger;
-          case "analytics":
-            return this.platform.analytics;
-          case "eventBus":
-            return this.platform.eventBus;
-          case "processExecutor":
-            if (!this.platform.processExecutor) {
-              throw new Error("Governed process executor is not configured on execution host");
-            }
-            return this.platform.processExecutor;
-          case "invoke":
-            return this.platform.invoke;
-          default:
-            throw new Error(
-              `Unknown adapter: '${name}'. Valid adapters: vectorStore, cache, config, llm, embeddings, storage, logger, analytics, eventBus, invoke, processExecutor`
-            );
-        }
+      getAdapterName() {
+        return this.adapterName;
       }
       /**
-       * Stop server and close all connections.
+       * Get the transport used by this proxy.
+       * Useful for advanced use cases (e.g., checking if transport is closed).
        */
-      async close() {
-        if (!this.started) {
-          return;
-        }
-        for (const client of this.clients) {
-          client.destroy();
-        }
-        this.clients.clear();
-        if (this.server) {
-          await new Promise((resolve9) => {
-            this.server.close(() => {
-              resolve9();
-            });
-          });
-          this.server = null;
-        }
-        if (fs5__namespace.existsSync(this.socketPath)) {
-          fs5__namespace.unlinkSync(this.socketPath);
-        }
-        this.started = false;
-        this.platform.logger.debug("UnixSocketServer stopped listening for adapter calls");
+      getTransport() {
+        return this.transport;
+      }
+    };
+    DocumentDatabaseProxy = class extends RemoteAdapter {
+      constructor(transport) {
+        super("database.document", transport);
+      }
+      async find(collection, filter2, options) {
+        return await this.callRemote("find", [collection, filter2, stripSignal(options)]);
+      }
+      // eslint-disable-next-line require-yield
+      async *findStream(_collection, _filter, _options) {
+        throw new Error(
+          "findStream() is not supported over IPC. Use bounded find({ limit }) and paginate explicitly."
+        );
+      }
+      async findById(collection, id, _options) {
+        return await this.callRemote("findById", [collection, id]);
+      }
+      async count(collection, filter2, _options) {
+        return await this.callRemote("count", [collection, filter2]);
+      }
+      async insertOne(collection, doc, _options) {
+        return await this.callRemote("insertOne", [collection, doc]);
+      }
+      async insertMany(collection, docs, _options) {
+        return await this.callRemote("insertMany", [collection, docs]);
+      }
+      async updateOne(collection, filter2, update, options) {
+        return await this.callRemote("updateOne", [
+          collection,
+          filter2,
+          update,
+          { upsert: options?.upsert }
+        ]);
+      }
+      async updateMany(collection, filter2, update, _options) {
+        return await this.callRemote("updateMany", [collection, filter2, update]);
+      }
+      async updateById(collection, id, update, _options) {
+        return await this.callRemote("updateById", [collection, id, update]);
+      }
+      async deleteMany(collection, filter2, _options) {
+        return await this.callRemote("deleteMany", [collection, filter2]);
+      }
+      async deleteById(collection, id, _options) {
+        return await this.callRemote("deleteById", [collection, id]);
+      }
+      async bulkWrite(collection, ops, _options) {
+        return await this.callRemote("bulkWrite", [collection, ops]);
+      }
+      async transaction(_fn) {
+        throw new Error(
+          "transaction() is not supported over IPC. Collect your writes into a single bulkWrite() instead."
+        );
+      }
+      async ensureCollection(name, options) {
+        await this.callRemote("ensureCollection", [name, options]);
+      }
+      async ping() {
+        return await this.callRemote("ping", []);
+      }
+      async close(options) {
+        await this.callRemote("close", [options]);
+      }
+    };
+    stripSignal = (options) => {
+      if (!options) {
+        return void 0;
+      }
+      const { signal: _signal, ...rest } = options;
+      return rest;
+    };
+    KVStoreProxy = class extends RemoteAdapter {
+      constructor(transport) {
+        super("database.kv", transport);
+      }
+      async get(key, _options) {
+        return await this.callRemote("get", [key]);
+      }
+      async getMany(keys, _options) {
+        return await this.callRemote("getMany", [keys]);
+      }
+      async set(key, value, options) {
+        return await this.callRemote("set", [key, value, stripSignal2(options)]);
+      }
+      async setMany(entries, _options) {
+        await this.callRemote("setMany", [entries]);
+      }
+      async setIfNotExists(key, value, options) {
+        return await this.callRemote("setIfNotExists", [key, value, stripSignal2(options)]);
+      }
+      async delete(key, _options) {
+        return await this.callRemote("delete", [key]);
+      }
+      async exists(key, _options) {
+        return await this.callRemote("exists", [key]);
+      }
+      async cas(key, expected, next, options) {
+        return await this.callRemote("cas", [key, expected, next, stripSignal2(options)]);
+      }
+      async incr(key, delta, options) {
+        return await this.callRemote("incr", [key, delta, stripSignal2(options)]);
+      }
+      async ttl(key) {
+        return await this.callRemote("ttl", [key]);
+      }
+      async expire(key, ttlMs) {
+        return await this.callRemote("expire", [key, ttlMs]);
+      }
+      async persist(key) {
+        return await this.callRemote("persist", [key]);
+      }
+      // eslint-disable-next-line require-yield
+      async *scan(_prefix, _options) {
+        throw new Error("scan() is not supported over IPC. Use bounded getMany() with an explicit key list.");
+      }
+      async ping() {
+        return await this.callRemote("ping", []);
+      }
+      async close(options) {
+        await this.callRemote("close", [options]);
+      }
+    };
+    stripSignal2 = (options) => {
+      if (!options) {
+        return void 0;
       }
+      const { signal: _signal, ...rest } = options;
+      return rest;
+    };
+    CacheProxy = class extends RemoteAdapter {
       /**
-       * Check if server is started.
+       * Create a cache proxy.
+       *
+       * @param transport - IPC transport to communicate with parent
        */
-      isStarted() {
-        return this.started;
+      constructor(transport) {
+        super("cache", transport);
       }
-    };
-    IPCServer = class {
       /**
-       * Create an IPC server.
+       * Get a value from cache.
        *
-       * @param platform - Platform container with real adapters
+       * @param key - Cache key
+       * @returns Cached value or null if not found/expired
        */
-      constructor(platform2) {
-        this.platform = platform2;
-        this.messageHandler = this.handleMessage.bind(this);
+      async get(key) {
+        return await this.callRemote("get", [key]);
       }
-      platform;
-      messageHandler;
-      started = false;
       /**
-       * Start listening for IPC messages.
+       * Set a value in cache.
        *
-       * Call this in the parent process (CLI bin) after initPlatform().
-       * The server will handle all adapter calls from child processes.
+       * @param key - Cache key
+       * @param value - Value to cache
+       * @param ttl - Time to live in milliseconds (optional)
+       */
+      async set(key, value, ttl) {
+        await this.callRemote("set", [key, value, ttl]);
+      }
+      /**
+       * Delete a value from cache.
        *
-       * @throws Error if already started
-       * @throws Error if not running in parent process with IPC
+       * @param key - Cache key
        */
-      start() {
-        if (this.started) {
-          throw new Error("IPCServer already started");
-        }
-        if (typeof process.on !== "function") {
-          throw new Error("IPCServer requires Node.js process object");
-        }
-        process.on("message", this.messageHandler);
-        this.started = true;
-        this.platform.logger.debug("IPCServer started listening for adapter calls");
+      async delete(key) {
+        await this.callRemote("delete", [key]);
       }
       /**
-       * Stop listening for IPC messages.
+       * Clear cache entries matching a pattern.
        *
-       * Removes the message listener. Pending calls will not receive responses.
+       * @param pattern - Glob pattern (e.g., 'user:*')
        */
-      stop() {
-        if (!this.started) {
-          return;
-        }
-        process.off("message", this.messageHandler);
-        this.started = false;
-        this.platform.logger.debug("IPCServer stopped listening for adapter calls");
+      async clear(pattern) {
+        await this.callRemote("clear", [pattern]);
       }
       /**
-       * Handle incoming IPC message.
+       * Add member to sorted set with score.
        *
-       * Validates message format, executes adapter call, and sends response.
+       * @param key - Sorted set key
+       * @param score - Numeric score (typically timestamp)
+       * @param member - Member to add
+       */
+      async zadd(key, score, member) {
+        await this.callRemote("zadd", [key, score, member]);
+      }
+      /**
+       * 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
+       */
+      async zrangebyscore(key, min, max) {
+        return await this.callRemote("zrangebyscore", [key, min, max]);
+      }
+      /**
+       * Remove member from sorted set.
+       *
+       * @param key - Sorted set key
+       * @param member - Member to remove
+       */
+      async zrem(key, member) {
+        await this.callRemote("zrem", [key, member]);
+      }
+      /**
+       * 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
+       */
+      async setIfNotExists(key, value, ttl) {
+        return await this.callRemote("setIfNotExists", [key, value, ttl]);
+      }
+    };
+    ConfigProxy = class extends RemoteAdapter {
+      /**
+       * Create a config proxy.
+       *
+       * @param transport - IPC transport to communicate with parent
+       */
+      constructor(transport) {
+        super("config", transport);
+      }
+      /**
+       * Get product-specific configuration.
+       *
+       * @param productId - Product identifier (e.g., 'mind', 'workflow', 'plugins')
+       * @param profileId - Profile identifier (defaults to 'default' or KB_PROFILE env var)
+       * @returns Promise resolving to product-specific config or undefined
+       *
+       * @example
+       * ```typescript
+       * const mindConfig = await config.getConfig('mind');
+       * if (mindConfig?.scopes) {
+       *   // Use scopes
+       * }
+       * ```
+       */
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      async getConfig(productId, profileId) {
+        return this.callRemote("getConfig", [productId, profileId]);
+      }
+      /**
+       * Get raw kb.config.json data.
+       *
+       * @returns Promise resolving to raw config object or undefined
+       *
+       * @example
+       * ```typescript
+       * const rawConfig = await config.getRawConfig();
+       * if (rawConfig) {
+       *   const allProfiles = rawConfig.profiles;
+       * }
+       * ```
+       */
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      async getRawConfig() {
+        return this.callRemote("getRawConfig", []);
+      }
+    };
+    VectorStoreProxy = class _VectorStoreProxy extends RemoteAdapter {
+      // Timeout for bulk operations that may trigger IPC backpressure
+      static BULK_OPERATION_TIMEOUT = 12e4;
+      // 2 minutes
+      // BulkTransfer configuration
+      bulkTransferOptions = {
+        maxInlineSize: 1e6,
+        // 1MB threshold
+        tempDir: process.env.KB_TEMP_DIR ?? os4.tmpdir()
+      };
+      /**
+       * Create a vector store proxy.
+       *
+       * @param transport - IPC transport to communicate with parent
+       */
+      constructor(transport) {
+        super("vectorStore", transport);
+      }
+      /**
+       * 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
+       */
+      async search(query, limit, filter2, namespace) {
+        return await this.callRemote("search", [query, limit, filter2, namespace]);
+      }
+      /**
+       * Insert or update vectors.
+       * Uses BulkTransfer for large payloads to avoid IPC backpressure.
+       *
+       * @param vectors - Vector records to upsert
+       */
+      async upsert(vectors, namespace) {
+        const transfer = await BulkTransferHelper.serialize(vectors, this.bulkTransferOptions);
+        await this.callRemote("upsert", [transfer, namespace], _VectorStoreProxy.BULK_OPERATION_TIMEOUT);
+      }
+      /**
+       * Delete vectors by IDs.
+       * Uses extended timeout for bulk deletions.
+       *
+       * @param ids - Vector IDs to delete
+       */
+      async delete(ids, namespace) {
+        await this.callRemote("delete", [ids, namespace], _VectorStoreProxy.BULK_OPERATION_TIMEOUT);
+      }
+      /**
+       * Count total vectors in collection.
+       *
+       * @returns Promise resolving to vector count
+       */
+      async count(namespace) {
+        return await this.callRemote("count", [namespace]);
+      }
+      /**
+       * 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
+       */
+      async get(ids, namespace) {
+        const resultTransfer = await this.callRemote("get", [ids, namespace], _VectorStoreProxy.BULK_OPERATION_TIMEOUT);
+        if (BulkTransferHelper.isBulkTransfer(resultTransfer)) {
+          return BulkTransferHelper.deserialize(resultTransfer);
+        }
+        return resultTransfer;
+      }
+      /**
+       * 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
+       */
+      async query(filter2, namespace) {
+        const resultTransfer = await this.callRemote("query", [filter2, namespace], _VectorStoreProxy.BULK_OPERATION_TIMEOUT);
+        if (BulkTransferHelper.isBulkTransfer(resultTransfer)) {
+          return BulkTransferHelper.deserialize(resultTransfer);
+        }
+        return resultTransfer;
+      }
+    };
+    InvokeProxy = class extends RemoteAdapter {
+      constructor(transport) {
+        super("invoke", transport);
+      }
+      async call(request) {
+        return await this.callRemote("call", [request]);
+      }
+      async isAvailable(pluginId, command) {
+        return await this.callRemote("isAvailable", [pluginId, command]);
+      }
+    };
+    documentDatabaseIPCOperations = defineIPCOperations()({
+      find: "unary",
+      findStream: "stream",
+      findById: "unary",
+      count: "unary",
+      insertOne: "unary",
+      insertMany: "unary",
+      updateOne: "unary",
+      updateMany: "unary",
+      updateById: "unary",
+      deleteMany: "unary",
+      deleteById: "unary",
+      bulkWrite: "unary",
+      transaction: "interactive",
+      ensureCollection: "unary",
+      ping: "unary",
+      close: "unary"
+    });
+    kvStoreIPCOperations = defineIPCOperations()({
+      get: "unary",
+      getMany: "unary",
+      set: "unary",
+      setMany: "unary",
+      setIfNotExists: "unary",
+      delete: "unary",
+      exists: "unary",
+      cas: "unary",
+      incr: "unary",
+      ttl: "unary",
+      expire: "unary",
+      persist: "unary",
+      scan: "stream",
+      ping: "unary",
+      close: "unary"
+    });
+    cacheIPCOperations = defineIPCOperations()({
+      get: "unary",
+      set: "unary",
+      delete: "unary",
+      clear: "unary",
+      zadd: "unary",
+      zrangebyscore: "unary",
+      zrem: "unary",
+      setIfNotExists: "unary"
+    });
+    configIPCOperations = defineIPCOperations()({
+      getConfig: "unary",
+      getRawConfig: "unary"
+    });
+    vectorStoreIPCOperations = defineIPCOperations()({
+      search: "unary",
+      upsert: "unary",
+      delete: "unary",
+      count: "unary",
+      get: "unary",
+      query: "unary"
+    });
+    invokeIPCOperations = defineIPCOperations()({
+      call: "unary",
+      isAvailable: "unary"
+    });
+    platformAdapterTransportPolicy = {
+      logger: {
+        mode: "migration",
+        adapter: "logger",
+        reason: "LoggerProxy is wired but still has fire-and-forget delivery semantics."
+      },
+      analytics: {
+        mode: "migration",
+        adapter: "analytics",
+        reason: "Optional read and source-management operations need a capability-aware IPC design."
+      },
+      vectorStore: {
+        mode: "ipc",
+        adapter: "vectorStore",
+        operations: vectorStoreIPCOperations,
+        proxy: createVectorStoreProxy
+      },
+      llm: {
+        mode: "migration",
+        adapter: "llm",
+        reason: "Streaming currently degrades to a completion over IPC."
+      },
+      embeddings: {
+        mode: "migration",
+        adapter: "embeddings",
+        reason: "The dimensions property requires out-of-band initialization in the proxy."
+      },
+      cache: {
+        mode: "ipc",
+        adapter: "cache",
+        operations: cacheIPCOperations,
+        proxy: createCacheProxy
+      },
+      config: {
+        mode: "ipc",
+        adapter: "config",
+        operations: configIPCOperations,
+        proxy: createConfigProxy
+      },
+      storage: {
+        mode: "migration",
+        adapter: "storage",
+        reason: "Node streams are not serializable over the current IPC protocol."
+      },
+      eventBus: {
+        mode: "migration",
+        adapter: "eventBus",
+        reason: "Subscriptions use a dedicated push-message protocol."
+      },
+      invoke: {
+        mode: "ipc",
+        adapter: "invoke",
+        operations: invokeIPCOperations,
+        proxy: createInvokeProxy
+      },
+      documentDatabase: {
+        mode: "ipc",
+        adapter: "database.document",
+        operations: documentDatabaseIPCOperations,
+        proxy: createDocumentDatabaseProxy
+      },
+      kvStore: {
+        mode: "ipc",
+        adapter: "database.kv",
+        operations: kvStoreIPCOperations,
+        proxy: createKVStoreProxy
+      },
+      logs: {
+        mode: "local-only",
+        reason: "Log queries are intentionally unavailable to worker processes."
+      },
+      artifacts: {
+        mode: "migration",
+        adapter: "artifacts",
+        reason: "Artifacts have a wire route but no worker proxy yet."
+      },
+      snapshotManager: {
+        mode: "local-only",
+        reason: "Snapshot lifecycle is owned by the execution host."
+      },
+      notifier: {
+        mode: "local-only",
+        reason: "Notifications are emitted by the host after worker execution."
+      },
+      processExecutor: {
+        mode: "migration",
+        adapter: "processExecutor",
+        reason: "Existing proxy must be moved to a checked operation inventory."
+      },
+      serviceTransport: {
+        mode: "local-only",
+        reason: "Service transport is a platform-internal adapter and never enters plugin context."
+      }
+    };
+    IPC_ADAPTER_ROUTES = createIPCAdapterRoutes();
+    UnixSocketServer = class {
+      /**
+       * Create a Unix Socket server.
+       *
+       * @param platform - Platform container with real adapters
+       * @param config - Server configuration
+       */
+      constructor(platform2, config2 = {}) {
+        this.platform = platform2;
+        this.socketPath = config2.socketPath ?? DEFAULT_SOCKET_PATH;
+        this.authToken = config2.authToken;
+      }
+      platform;
+      server = null;
+      clients = /* @__PURE__ */ new Set();
+      socketPath;
+      authToken;
+      started = false;
+      /**
+       * Get the socket path.
+       * Used by parent process to pass to child processes via env var.
+       */
+      getSocketPath() {
+        return this.socketPath;
+      }
+      /**
+       * Start listening for connections.
+       */
+      async start() {
+        BulkTransferHelper.registerSignalHandlers();
+        if (fs5__namespace.existsSync(this.socketPath)) {
+          fs5__namespace.unlinkSync(this.socketPath);
+        }
+        return new Promise((resolve9, reject) => {
+          this.server = net__namespace.createServer((socket) => {
+            this.handleClient(socket);
+          });
+          this.server.on("error", (error2) => {
+            reject(error2);
+          });
+          this.server.listen(this.socketPath, () => {
+            fs5__namespace.chmodSync(this.socketPath, 438);
+            this.started = true;
+            this.platform.logger.debug("UnixSocketServer started listening for adapter calls");
+            resolve9();
+          });
+        });
+      }
+      /**
+       * Handle new client connection.
+       */
+      handleClient(socket) {
+        this.clients.add(socket);
+        let buffer = "";
+        socket.on("data", (data) => {
+          buffer += data.toString("utf8");
+          let newlineIndex;
+          while ((newlineIndex = buffer.indexOf("\n")) !== -1) {
+            const line = buffer.slice(0, newlineIndex);
+            buffer = buffer.slice(newlineIndex + 1);
+            if (line.trim().length === 0) {
+              continue;
+            }
+            try {
+              const call = JSON.parse(line);
+              this.handleCall(socket, call);
+            } catch (error2) {
+              this.platform.logger.warn("UnixSocketServer: failed to parse message", { error: error2 });
+            }
+          }
+        });
+        socket.on("close", () => {
+          this.clients.delete(socket);
+        });
+        socket.on("error", (error2) => {
+          this.platform.logger.warn("UnixSocketServer: client socket error", { error: error2 });
+          this.clients.delete(socket);
+        });
+      }
+      /**
+       * Handle adapter call from client.
+       */
+      async handleCall(socket, call) {
+        const callAuthToken = call.context?.authToken;
+        if (this.authToken && callAuthToken !== this.authToken) {
+          const response = {
+            type: "adapter:response",
+            requestId: call.requestId,
+            error: toSerializableError(new Error("Unauthorized IPC call: invalid auth token"))
+          };
+          socket.write(JSON.stringify(response) + "\n", "utf8");
+          return;
+        }
+        if (call.version !== IPC_PROTOCOL_VERSION) {
+          this.platform.logger.warn("UnixSocketServer: protocol version mismatch", {
+            received: call.version,
+            expected: IPC_PROTOCOL_VERSION,
+            adapter: call.adapter,
+            method: call.method,
+            note: "Child process may be using outdated protocol. Consider rebuilding."
+          });
+        }
+        if (call.context) {
+          this.platform.logger.debug("UnixSocketServer: adapter call", {
+            version: call.version,
+            traceId: call.context.traceId,
+            pluginId: call.context.pluginId,
+            sessionId: call.context.sessionId,
+            tenantId: call.context.tenantId,
+            adapter: call.adapter,
+            method: call.method
+          });
+        }
+        try {
+          const adapter = resolveIPCAdapter(this.platform, call.adapter);
+          if (adapter === null || typeof adapter !== "object" && typeof adapter !== "function") {
+            throw new Error(`Adapter '${call.adapter}' is not callable`);
+          }
+          const method = Reflect.get(adapter, call.method);
+          if (typeof method !== "function") {
+            throw new Error(
+              `Method '${call.method}' not found on adapter '${call.adapter}'. Available methods: ${Object.getOwnPropertyNames(Object.getPrototypeOf(adapter)).join(", ")}`
+            );
+          }
+          const args = await Promise.all(
+            call.args.map(async (arg) => {
+              const deserialized = deserialize(arg);
+              if (BulkTransferHelper.isBulkTransfer(deserialized)) {
+                return BulkTransferHelper.deserialize(deserialized);
+              }
+              return deserialized;
+            })
+          );
+          const result = await method.apply(adapter, args);
+          let serializedResult;
+          if (result !== void 0 && result !== null && typeof result === "object") {
+            const resultJson = JSON.stringify(result);
+            if (resultJson.length > 1e6) {
+              const transfer = await BulkTransferHelper.serialize(result, {
+                maxInlineSize: 1e6,
+                tempDir: process.env.KB_TEMP_DIR ?? os4__namespace.tmpdir()
+              });
+              serializedResult = serialize(transfer);
+            } else {
+              serializedResult = serialize(result);
+            }
+          } else {
+            serializedResult = serialize(result);
+          }
+          const response = {
+            type: "adapter:response",
+            requestId: call.requestId,
+            result: serializedResult
+          };
+          const message2 = JSON.stringify(response) + "\n";
+          socket.write(message2, "utf8");
+        } catch (error2) {
+          const response = {
+            type: "adapter:response",
+            requestId: call.requestId,
+            error: toSerializableError(error2)
+          };
+          const message2 = JSON.stringify(response) + "\n";
+          socket.write(message2, "utf8");
+          const cause = error2 instanceof Error ? error2.message : String(error2);
+          this.platform.logger.error(
+            `UnixSocketServer: ${call.adapter}.${call.method} failed \u2014 ${cause}`,
+            error2 instanceof Error ? error2 : new Error(String(error2)),
+            { adapter: call.adapter, method: call.method }
+          );
+        }
+      }
+      /**
+       * Stop server and close all connections.
+       */
+      async close() {
+        if (!this.started) {
+          return;
+        }
+        for (const client of this.clients) {
+          client.destroy();
+        }
+        this.clients.clear();
+        if (this.server) {
+          await new Promise((resolve9) => {
+            this.server.close(() => {
+              resolve9();
+            });
+          });
+          this.server = null;
+        }
+        if (fs5__namespace.existsSync(this.socketPath)) {
+          fs5__namespace.unlinkSync(this.socketPath);
+        }
+        this.started = false;
+        this.platform.logger.debug("UnixSocketServer stopped listening for adapter calls");
+      }
+      /**
+       * Check if server is started.
+       */
+      isStarted() {
+        return this.started;
+      }
+    };
+    IPCServer = class {
+      /**
+       * Create an IPC server.
+       *
+       * @param platform - Platform container with real adapters
+       */
+      constructor(platform2) {
+        this.platform = platform2;
+        this.messageHandler = this.handleMessage.bind(this);
+      }
+      platform;
+      messageHandler;
+      started = false;
+      /**
+       * Start listening for IPC messages.
+       *
+       * Call this in the parent process (CLI bin) after initPlatform().
+       * The server will handle all adapter calls from child processes.
+       *
+       * @throws Error if already started
+       * @throws Error if not running in parent process with IPC
+       */
+      start() {
+        if (this.started) {
+          throw new Error("IPCServer already started");
+        }
+        if (typeof process.on !== "function") {
+          throw new Error("IPCServer requires Node.js process object");
+        }
+        process.on("message", this.messageHandler);
+        this.started = true;
+        this.platform.logger.debug("IPCServer started listening for adapter calls");
+      }
+      /**
+       * Stop listening for IPC messages.
+       *
+       * Removes the message listener. Pending calls will not receive responses.
+       */
+      stop() {
+        if (!this.started) {
+          return;
+        }
+        process.off("message", this.messageHandler);
+        this.started = false;
+        this.platform.logger.debug("IPCServer stopped listening for adapter calls");
+      }
+      /**
+       * Handle incoming IPC message.
+       *
+       * Validates message format, executes adapter call, and sends response.
        */
       async handleMessage(msg, sendHandle) {
         if (!isAdapterCall(msg)) {
@@ -4134,7 +4758,7 @@ var init_dist5 = __esm({
           });
         }
         try {
-          const adapter = this.getAdapter(msg.adapter);
+          const adapter = resolveIPCAdapter(this.platform, msg.adapter);
           const method = adapter[msg.method];
           if (typeof method !== "function") {
             throw new Error(
@@ -4167,44 +4791,6 @@ var init_dist5 = __esm({
           );
         }
       }
-      /**
-       * Get adapter instance from platform container.
-       *
-       * @param name - Adapter name (e.g., 'vectorStore', 'cache')
-       * @returns Adapter instance
-       * @throws Error if adapter not found
-       */
-      getAdapter(name) {
-        switch (name) {
-          case "vectorStore":
-            return this.platform.vectorStore;
-          case "cache":
-            return this.platform.cache;
-          case "llm":
-            return this.platform.llm;
-          case "embeddings":
-            return this.platform.embeddings;
-          case "storage":
-            return this.platform.storage;
-          case "logger":
-            return this.platform.logger;
-          case "analytics":
-            return this.platform.analytics;
-          case "eventBus":
-            return this.platform.eventBus;
-          case "invoke":
-            return this.platform.invoke;
-          case "processExecutor":
-            if (!this.platform.processExecutor) {
-              throw new Error("Governed process executor is not configured on execution host");
-            }
-            return this.platform.processExecutor;
-          default:
-            throw new Error(
-              `Unknown adapter: '${name}'. Valid adapters: vectorStore, cache, llm, embeddings, storage, logger, analytics, eventBus, invoke, processExecutor`
-            );
-        }
-      }
       /**
        * Check if server is started.
        */
@@ -4292,7 +4878,7 @@ var init_dist5 = __esm({
           return;
         }
         try {
-          const adapter = this.getAdapter(msg.adapter);
+          const adapter = resolveIPCAdapter(this.platform, msg.adapter);
           const method = adapter[msg.method];
           if (typeof method !== "function") {
             throw new Error(
@@ -4343,25 +4929,6 @@ var init_dist5 = __esm({
           this.child.send(response);
         }
       }
-      /**
-       * Get adapter from platform by name.
-       * Dynamic dispatch — no hardcoded switch; new adapters in IPlatformAdapters
-       * are automatically available without touching this file.
-       * The dotted names ('database.document', 'database.kv') are mapped explicitly.
-       */
-      getAdapter(name) {
-        if (name === "database.document") {
-          return this.platform.documentDatabase;
-        }
-        if (name === "database.kv") {
-          return this.platform.kvStore;
-        }
-        const adapter = this.platform[name];
-        if (adapter === void 0) {
-          throw new Error(`Unknown adapter: '${name}'`);
-        }
-        return adapter;
-      }
       isStarted() {
         return this.started;
       }
@@ -4636,19 +5203,23 @@ Caused by: ${cause.stack}`;
           throw new TransportError("Socket not available");
         }
         const timeout = selectTimeout(call, this.config.timeout);
+        const outboundCall = this.config.authToken ? {
+          ...call,
+          context: { ...call.context, authToken: this.config.authToken }
+        } : call;
         return new Promise((resolve9, reject) => {
           const timer = setTimeout(() => {
             this.pending.delete(call.requestId);
             reject(new TimeoutError(`Adapter call timed out after ${timeout}ms`, timeout));
           }, timeout);
-          this.pending.set(call.requestId, { resolve: resolve9, reject, timer });
-          const message2 = JSON.stringify(call) + "\n";
+          this.pending.set(outboundCall.requestId, { resolve: resolve9, reject, timer });
+          const message2 = JSON.stringify(outboundCall) + "\n";
           const written = this.socket.write(message2, "utf8", (error2) => {
             if (error2) {
-              const pending = this.pending.get(call.requestId);
+              const pending = this.pending.get(outboundCall.requestId);
               if (pending) {
                 clearTimeout(pending.timer);
-                this.pending.delete(call.requestId);
+                this.pending.delete(outboundCall.requestId);
                 reject(new TransportError(`Failed to write to socket: ${error2.message}`, error2));
               }
             }
@@ -4716,202 +5287,9 @@ Caused by: ${cause.stack}`;
         };
       }
     };
-    RemoteAdapter = class {
+    LLMProxy = class extends RemoteAdapter {
       /**
-       * 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, transport, context) {
-        this.adapterName = adapterName;
-        this.transport = transport;
-        this.context = context;
-      }
-      adapterName;
-      transport;
-      context;
-      /**
-       * 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) {
-        this.context = context;
-      }
-      /**
-       * Get current execution context.
-       */
-      getContext() {
-        return this.context;
-      }
-      /**
-       * 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
-       * ```
-       */
-      async callRemote(method, args, timeout) {
-        const requestId = crypto4.randomUUID();
-        const call = {
-          version: IPC_PROTOCOL_VERSION,
-          // Protocol version for backward compatibility
-          type: "adapter:call",
-          requestId,
-          adapter: this.adapterName,
-          method,
-          args: args.map((arg) => serialize(arg)),
-          timeout,
-          // Optional timeout for this specific call
-          context: this.context
-          // Include execution context for tracing/debugging
-        };
-        const response = await this.transport.send(call);
-        if (response.error) {
-          throw deserialize(response.error);
-        }
-        if (response.result === void 0) {
-          return void 0;
-        }
-        const result = deserialize(response.result);
-        if (BulkTransferHelper.isBulkTransfer(result)) {
-          return BulkTransferHelper.deserialize(result);
-        }
-        return result;
-      }
-      /**
-       * Get the adapter name this proxy represents.
-       */
-      getAdapterName() {
-        return this.adapterName;
-      }
-      /**
-       * Get the transport used by this proxy.
-       * Useful for advanced use cases (e.g., checking if transport is closed).
-       */
-      getTransport() {
-        return this.transport;
-      }
-    };
-    CacheProxy = class extends RemoteAdapter {
-      /**
-       * Create a cache proxy.
-       *
-       * @param transport - IPC transport to communicate with parent
-       */
-      constructor(transport) {
-        super("cache", transport);
-      }
-      /**
-       * Get a value from cache.
-       *
-       * @param key - Cache key
-       * @returns Cached value or null if not found/expired
-       */
-      async get(key) {
-        return await this.callRemote("get", [key]);
-      }
-      /**
-       * Set a value in cache.
-       *
-       * @param key - Cache key
-       * @param value - Value to cache
-       * @param ttl - Time to live in milliseconds (optional)
-       */
-      async set(key, value, ttl) {
-        await this.callRemote("set", [key, value, ttl]);
-      }
-      /**
-       * Delete a value from cache.
-       *
-       * @param key - Cache key
-       */
-      async delete(key) {
-        await this.callRemote("delete", [key]);
-      }
-      /**
-       * Clear cache entries matching a pattern.
-       *
-       * @param pattern - Glob pattern (e.g., 'user:*')
-       */
-      async clear(pattern) {
-        await this.callRemote("clear", [pattern]);
-      }
-      /**
-       * Add member to sorted set with score.
-       *
-       * @param key - Sorted set key
-       * @param score - Numeric score (typically timestamp)
-       * @param member - Member to add
-       */
-      async zadd(key, score, member) {
-        await this.callRemote("zadd", [key, score, member]);
-      }
-      /**
-       * 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
-       */
-      async zrangebyscore(key, min, max) {
-        return await this.callRemote("zrangebyscore", [key, min, max]);
-      }
-      /**
-       * Remove member from sorted set.
-       *
-       * @param key - Sorted set key
-       * @param member - Member to remove
-       */
-      async zrem(key, member) {
-        await this.callRemote("zrem", [key, member]);
-      }
-      /**
-       * 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
-       */
-      async setIfNotExists(key, value, ttl) {
-        return await this.callRemote("setIfNotExists", [key, value, ttl]);
-      }
-    };
-    LLMProxy = class extends RemoteAdapter {
-      /**
-       * Create an LLM proxy.
+       * Create an LLM proxy.
        *
        * @param transport - IPC transport to communicate with parent
        */
@@ -5034,123 +5412,6 @@ Caused by: ${cause.stack}`;
         return this._dimensions;
       }
     };
-    VectorStoreProxy = class _VectorStoreProxy extends RemoteAdapter {
-      // Timeout for bulk operations that may trigger IPC backpressure
-      static BULK_OPERATION_TIMEOUT = 12e4;
-      // 2 minutes
-      // BulkTransfer configuration
-      bulkTransferOptions = {
-        maxInlineSize: 1e6,
-        // 1MB threshold
-        tempDir: process.env.KB_TEMP_DIR ?? os4.tmpdir()
-      };
-      /**
-       * Create a vector store proxy.
-       *
-       * @param transport - IPC transport to communicate with parent
-       */
-      constructor(transport) {
-        super("vectorStore", transport);
-      }
-      /**
-       * 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
-       */
-      async search(query, limit, filter2, namespace) {
-        return await this.callRemote("search", [query, limit, filter2, namespace]);
-      }
-      /**
-       * Insert or update vectors.
-       * Uses BulkTransfer for large payloads to avoid IPC backpressure.
-       *
-       * @param vectors - Vector records to upsert
-       */
-      async upsert(vectors, namespace) {
-        const transfer = await BulkTransferHelper.serialize(vectors, this.bulkTransferOptions);
-        await this.callRemote("upsert", [transfer, namespace], _VectorStoreProxy.BULK_OPERATION_TIMEOUT);
-      }
-      /**
-       * Delete vectors by IDs.
-       * Uses extended timeout for bulk deletions.
-       *
-       * @param ids - Vector IDs to delete
-       */
-      async delete(ids, namespace) {
-        await this.callRemote("delete", [ids, namespace], _VectorStoreProxy.BULK_OPERATION_TIMEOUT);
-      }
-      /**
-       * 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
-       */
-      async upsertChunks(scope, vectors) {
-        await this.callRemote("upsertChunks", [scope, vectors], _VectorStoreProxy.BULK_OPERATION_TIMEOUT);
-      }
-      /**
-       * Count total vectors in collection.
-       *
-       * @returns Promise resolving to vector count
-       */
-      async count(namespace) {
-        return await this.callRemote("count", [namespace]);
-      }
-      /**
-       * 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
-       */
-      async get(ids, namespace) {
-        const resultTransfer = await this.callRemote("get", [ids, namespace], _VectorStoreProxy.BULK_OPERATION_TIMEOUT);
-        if (BulkTransferHelper.isBulkTransfer(resultTransfer)) {
-          return BulkTransferHelper.deserialize(resultTransfer);
-        }
-        return resultTransfer;
-      }
-      /**
-       * 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
-       */
-      async query(filter2, namespace) {
-        const resultTransfer = await this.callRemote("query", [filter2, namespace], _VectorStoreProxy.BULK_OPERATION_TIMEOUT);
-        if (BulkTransferHelper.isBulkTransfer(resultTransfer)) {
-          return BulkTransferHelper.deserialize(resultTransfer);
-        }
-        return resultTransfer;
-      }
-      /**
-       * Clear all vectors from collection.
-       * Uses extended timeout for bulk deletion.
-       */
-      async clear() {
-        await this.callRemote("clear", [], _VectorStoreProxy.BULK_OPERATION_TIMEOUT);
-      }
-      /**
-       * Initialize the vector store.
-       * Called during platform initialization.
-       */
-      async initialize() {
-        await this.callRemote("initialize", []);
-      }
-      /**
-       * Close connections and cleanup resources.
-       */
-      async close() {
-        await this.callRemote("close", []);
-      }
-    };
     StorageProxy = class extends RemoteAdapter {
       /**
        * Create a storage proxy.
@@ -5248,180 +5509,6 @@ Caused by: ${cause.stack}`;
         return await this.callRemote("listWithMetadata", [prefix]);
       }
     };
-    DocumentDatabaseProxy = class extends RemoteAdapter {
-      constructor(transport) {
-        super("database.document", transport);
-      }
-      async find(collection, filter2, options) {
-        return await this.callRemote("find", [collection, filter2, stripSignal(options)]);
-      }
-      // eslint-disable-next-line require-yield
-      async *findStream(_collection, _filter, _options) {
-        throw new Error(
-          "findStream() is not supported over IPC. Use bounded find({ limit }) and paginate explicitly."
-        );
-      }
-      async findById(collection, id, _options) {
-        return await this.callRemote("findById", [collection, id]);
-      }
-      async count(collection, filter2, _options) {
-        return await this.callRemote("count", [collection, filter2]);
-      }
-      async insertOne(collection, doc, _options) {
-        return await this.callRemote("insertOne", [collection, doc]);
-      }
-      async insertMany(collection, docs, _options) {
-        return await this.callRemote("insertMany", [collection, docs]);
-      }
-      async updateOne(collection, filter2, update, options) {
-        return await this.callRemote("updateOne", [
-          collection,
-          filter2,
-          update,
-          { upsert: options?.upsert }
-        ]);
-      }
-      async updateMany(collection, filter2, update, _options) {
-        return await this.callRemote("updateMany", [collection, filter2, update]);
-      }
-      async updateById(collection, id, update, _options) {
-        return await this.callRemote("updateById", [collection, id, update]);
-      }
-      async deleteMany(collection, filter2, _options) {
-        return await this.callRemote("deleteMany", [collection, filter2]);
-      }
-      async deleteById(collection, id, _options) {
-        return await this.callRemote("deleteById", [collection, id]);
-      }
-      async bulkWrite(collection, ops, _options) {
-        return await this.callRemote("bulkWrite", [collection, ops]);
-      }
-      async transaction(_fn) {
-        throw new Error(
-          "transaction() is not supported over IPC. Collect your writes into a single bulkWrite() instead."
-        );
-      }
-      async ensureCollection(name, options) {
-        await this.callRemote("ensureCollection", [name, options]);
-      }
-      async ping() {
-        return await this.callRemote("ping", []);
-      }
-      async close(options) {
-        await this.callRemote("close", [options]);
-      }
-    };
-    stripSignal = (options) => {
-      if (!options) {
-        return void 0;
-      }
-      const { signal: _signal, ...rest } = options;
-      return rest;
-    };
-    KVStoreProxy = class extends RemoteAdapter {
-      constructor(transport) {
-        super("database.kv", transport);
-      }
-      async get(key, _options) {
-        return await this.callRemote("get", [key]);
-      }
-      async getMany(keys, _options) {
-        return await this.callRemote("getMany", [keys]);
-      }
-      async set(key, value, options) {
-        return await this.callRemote("set", [key, value, stripSignal2(options)]);
-      }
-      async setMany(entries, _options) {
-        await this.callRemote("setMany", [entries]);
-      }
-      async setIfNotExists(key, value, options) {
-        return await this.callRemote("setIfNotExists", [key, value, stripSignal2(options)]);
-      }
-      async delete(key, _options) {
-        return await this.callRemote("delete", [key]);
-      }
-      async exists(key, _options) {
-        return await this.callRemote("exists", [key]);
-      }
-      async cas(key, expected, next, options) {
-        return await this.callRemote("cas", [key, expected, next, stripSignal2(options)]);
-      }
-      async incr(key, delta, options) {
-        return await this.callRemote("incr", [key, delta, stripSignal2(options)]);
-      }
-      async ttl(key) {
-        return await this.callRemote("ttl", [key]);
-      }
-      async expire(key, ttlMs) {
-        return await this.callRemote("expire", [key, ttlMs]);
-      }
-      async persist(key) {
-        return await this.callRemote("persist", [key]);
-      }
-      // eslint-disable-next-line require-yield
-      async *scan(_prefix, _options) {
-        throw new Error("scan() is not supported over IPC. Use bounded getMany() with an explicit key list.");
-      }
-      async ping() {
-        return await this.callRemote("ping", []);
-      }
-      async close(options) {
-        await this.callRemote("close", [options]);
-      }
-    };
-    stripSignal2 = (options) => {
-      if (!options) {
-        return void 0;
-      }
-      const { signal: _signal, ...rest } = options;
-      return rest;
-    };
-    ConfigProxy = class extends RemoteAdapter {
-      /**
-       * Create a config proxy.
-       *
-       * @param transport - IPC transport to communicate with parent
-       */
-      constructor(transport) {
-        super("config", transport);
-      }
-      /**
-       * Get product-specific configuration.
-       *
-       * @param productId - Product identifier (e.g., 'mind', 'workflow', 'plugins')
-       * @param profileId - Profile identifier (defaults to 'default' or KB_PROFILE env var)
-       * @returns Promise resolving to product-specific config or undefined
-       *
-       * @example
-       * ```typescript
-       * const mindConfig = await config.getConfig('mind');
-       * if (mindConfig?.scopes) {
-       *   // Use scopes
-       * }
-       * ```
-       */
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      async getConfig(productId, profileId) {
-        return this.callRemote("getConfig", [productId, profileId]);
-      }
-      /**
-       * Get raw kb.config.json data.
-       *
-       * @returns Promise resolving to raw config object or undefined
-       *
-       * @example
-       * ```typescript
-       * const rawConfig = await config.getRawConfig();
-       * if (rawConfig) {
-       *   const allProfiles = rawConfig.profiles;
-       * }
-       * ```
-       */
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      async getRawConfig() {
-        return this.callRemote("getRawConfig", []);
-      }
-    };
     EventBusProxy = class {
       constructor(transport) {
         this.transport = transport;
@@ -27449,21 +27536,29 @@ function getHandlerPermissions(manifest, host, id) {
   let handlerPerms;
   switch (host) {
     case "cli":
-      handlerPerms = manifest.cli?.commands.find((cmd) => cmd.path === id)?.permissions;
+      handlerPerms = manifest.cli?.commands.find(
+        (cmd) => cmd.path === id
+      )?.permissions;
       break;
     case "rest":
       handlerPerms = manifest.rest?.routes.find(
         (route) => `${route.method} ${route.path}` === id
-      )?.permissions;
+      )?.permissions ?? manifest.sse?.streams.find((stream2) => stream2.path === id)?.permissions;
       break;
     case "ws":
-      handlerPerms = manifest.ws?.channels.find((ch) => ch.path === id)?.permissions;
+      handlerPerms = manifest.ws?.channels.find(
+        (ch) => ch.path === id
+      )?.permissions;
       break;
     case "workflow":
-      handlerPerms = manifest.workflows?.handlers.find((h) => h.id === id)?.permissions;
+      handlerPerms = manifest.workflows?.handlers.find(
+        (h) => h.id === id
+      )?.permissions;
       break;
     case "webhook":
-      handlerPerms = manifest.webhooks?.handlers.find((h) => h.event === id)?.permissions;
+      handlerPerms = manifest.webhooks?.handlers.find(
+        (h) => h.event === id
+      )?.permissions;
       break;
   }
   return {
@@ -80108,1368 +80203,330 @@ var init_container = __esm3({
        */
       initSocketServer(server) {
         this._socketServer = server;
-      }
-      /**
-       * Get socket path for IPC communication.
-       * Returns undefined if not running in parent process.
-       */
-      getSocketPath() {
-        return this._socketServer?.getSocketPath();
-      }
-      /**
-       * Initialize execution backend.
-       * Called internally by initPlatform() AFTER adapters, BEFORE core features.
-       *
-       * @param backend - ExecutionBackend instance (from @kb-labs/plugin-execution)
-       */
-      initExecutionBackend(backend) {
-        if (this._executionBackend) {
-          this.logger.warn("ExecutionBackend already initialized, replacing");
-        }
-        this._executionBackend = backend;
-        this.logger.debug("ExecutionBackend initialized", {
-          mode: backend.constructor.name
-        });
-      }
-      /**
-       * 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() {
-        if (!this._executionBackend) {
-          throw new Error(
-            "ExecutionBackend not initialized. Call initPlatform() with execution config to initialize ExecutionBackend."
-          );
-        }
-        return this._executionBackend;
-      }
-      /**
-       * Check if execution backend is initialized.
-       */
-      get hasExecutionBackend() {
-        return !!this._executionBackend;
-      }
-      /**
-       * Initialize orchestration services.
-       * Called internally by initPlatform() after ExecutionBackend init.
-       */
-      initOrchestrationServices(environmentManager, runExecutor, runOrchestrator) {
-        this._environmentManager = environmentManager;
-        this._runExecutor = runExecutor;
-        this._runOrchestrator = runOrchestrator;
-      }
-      /**
-       * Initialize infrastructure capability services.
-       * Called internally by initPlatform().
-       */
-      initCapabilityServices(workspaceManager, snapshotManager) {
-        this._workspaceManager = workspaceManager;
-        this._snapshotManager = snapshotManager;
-      }
-      /**
-       * Environment manager service.
-       * Returns undefined when not initialized (e.g., proxy/minimal platforms).
-       */
-      get environmentManager() {
-        return this._environmentManager;
-      }
-      /**
-       * Workspace manager service.
-       * Returns undefined when not initialized (e.g., proxy/minimal platforms).
-       */
-      get workspaceManager() {
-        return this._workspaceManager;
-      }
-      /**
-       * Snapshot manager service.
-       * Returns undefined when not initialized (e.g., proxy/minimal platforms).
-       */
-      get snapshotManager() {
-        return this._snapshotManager;
-      }
-      /**
-       * Run executor service.
-       */
-      get runExecutor() {
-        if (!this._runExecutor) {
-          throw new Error("RunExecutor not initialized. Call initPlatform() first.");
-        }
-        return this._runExecutor;
-      }
-      /**
-       * Run orchestrator service.
-       */
-      get runOrchestrator() {
-        if (!this._runOrchestrator) {
-          throw new Error(
-            "RunOrchestrator not initialized. Call initPlatform() first."
-          );
-        }
-        return this._runOrchestrator;
-      }
-      /**
-       * Check if platform is initialized.
-       */
-      get isInitialized() {
-        return this.initialized;
-      }
-      /**
-       * Reset platform to initial state.
-       * Clears all adapters and core features.
-       * Used primarily for testing.
-       */
-      reset() {
-        this.adapters.clear();
-        this.adapters.set("logger", new ConsoleLogger());
-        this.lifecycleHooks.clear();
-        this._workflows = void 0;
-        this._jobs = void 0;
-        this._cron = void 0;
-        this._resources = void 0;
-        this._resourceBroker = void 0;
-        this._socketServer = void 0;
-        this._executionBackend = void 0;
-        this._environmentManager = void 0;
-        this._workspaceManager = void 0;
-        this._snapshotManager = void 0;
-        this._runExecutor = void 0;
-        this._runOrchestrator = void 0;
-        this.initialized = false;
-        this.assembled = false;
-      }
-      /**
-       * Shutdown platform gracefully.
-       * Closes all resources, stops workers, cleanup.
-       */
-      async shutdown() {
-        await this.emitLifecyclePhase("beforeShutdown", {
-          reason: "platform.shutdown",
-          metadata: {
-            adapterCount: this.adapters.size,
-            hasExecutionBackend: !!this._executionBackend
-          }
-        });
-        if (this._executionBackend) {
-          try {
-            await this._executionBackend.shutdown();
-          } catch (error2) {
-            this.logger.warn("ExecutionBackend shutdown failed", {
-              error: error2 instanceof Error ? error2.message : String(error2)
-            });
-          }
-        }
-        if (this._environmentManager) {
-          try {
-            await this._environmentManager.shutdown();
-          } catch (error2) {
-            this.logger.warn("EnvironmentManager shutdown failed", {
-              error: error2 instanceof Error ? error2.message : String(error2)
-            });
-          }
-        }
-        if (this._workspaceManager) {
-          try {
-            await this._workspaceManager.shutdown();
-          } catch (error2) {
-            this.logger.warn("WorkspaceManager shutdown failed", {
-              error: error2 instanceof Error ? error2.message : String(error2)
-            });
-          }
-        }
-        if (this._snapshotManager) {
-          try {
-            await this._snapshotManager.shutdown();
-          } catch (error2) {
-            this.logger.warn("SnapshotManager shutdown failed", {
-              error: error2 instanceof Error ? error2.message : String(error2)
-            });
-          }
-        }
-        const adaptersInReverseLoadOrder = Array.from(this.adapters.entries()).reverse();
-        for (const [adapterId, adapter] of adaptersInReverseLoadOrder) {
-          if (!adapter || adapter === this._executionBackend) {
-            continue;
-          }
-          const candidate = adapter;
-          try {
-            if (typeof candidate.close === "function") {
-              await candidate.close.call(adapter);
-            } else if (typeof candidate.dispose === "function") {
-              await candidate.dispose.call(adapter);
-            } else if (typeof candidate.shutdown === "function") {
-              await candidate.shutdown.call(adapter);
-            }
-          } catch (error2) {
-            this.logger.warn("Adapter shutdown failed", {
-              adapterId,
-              error: error2 instanceof Error ? error2.message : String(error2)
-            });
-          }
-        }
-        await this.emitLifecyclePhase("shutdown", {
-          reason: "platform.shutdown",
-          metadata: {
-            adapterCount: this.adapters.size
-          }
-        });
-      }
-    };
-    PLATFORM_SINGLETON_KEY = /* @__PURE__ */ Symbol.for("kb.platform");
-    platform = (() => {
-      const existing = getPlatformFromProcess();
-      if (existing && typeof existing.setAdapter === "function" && typeof existing.getAdapter === "function") {
-        return existing;
-      }
-      const newPlatform = new PlatformContainer();
-      setPlatformInProcess(newPlatform);
-      return newPlatform;
-    })();
-  }
-});
-var discover_adapters_exports = {};
-__export3(discover_adapters_exports, {
-  discoverAdapters: () => discoverAdapters,
-  resolveAdapter: () => resolveAdapter
-});
-async function loadAdapterModule(distPath) {
-  const fileUrl = url$1.pathToFileURL(distPath).href;
-  return import(fileUrl);
-}
-async function loadAdaptersFromLock(root, discovered, overwrite) {
-  const diag2 = new DiagnosticCollector();
-  const lock = await readMarketplaceLock(root, diag2);
-  if (!lock) {
-    return;
-  }
-  for (const [pkgId, entry] of Object.entries(lock.installed)) {
-    if (entry.primaryKind !== "adapter") {
-      continue;
-    }
-    if (entry.enabled === false) {
-      continue;
-    }
-    const pkgRoot = path13__namespace.default.resolve(root, entry.resolvedPath);
-    let mainPath = "dist/index.js";
-    let npmPkgName;
-    try {
-      const pkgContent = await fs5.promises.readFile(path13__namespace.default.join(pkgRoot, "package.json"), "utf-8");
-      const pkg = JSON.parse(pkgContent);
-      mainPath = pkg.main || mainPath;
-      npmPkgName = pkg.name;
-    } catch {
-    }
-    const distPath = path13__namespace.default.join(pkgRoot, mainPath);
-    try {
-      await fs5.promises.access(distPath);
-      const module = await loadAdapterModule(distPath);
-      if (typeof module.createAdapter !== "function") {
-        continue;
-      }
-      const adapterEntry = {
-        packageName: npmPkgName ?? pkgId,
-        pkgRoot,
-        createAdapter: module.createAdapter,
-        module
-      };
-      if (overwrite || !discovered.has(pkgId)) {
-        discovered.set(pkgId, adapterEntry);
-      }
-      if (npmPkgName && npmPkgName !== pkgId) {
-        if (overwrite || !discovered.has(npmPkgName)) {
-          discovered.set(npmPkgName, adapterEntry);
-        }
-      }
-    } catch {
-    }
-  }
-}
-async function discoverAdapters(platformRoot, projectRoot) {
-  const discovered = /* @__PURE__ */ new Map();
-  if (projectRoot && projectRoot !== platformRoot) {
-    await loadAdaptersFromLock(
-      projectRoot,
-      discovered,
-      /* overwrite= */
-      true
-    );
-  }
-  await loadAdaptersFromLock(
-    platformRoot,
-    discovered,
-    /* overwrite= */
-    false
-  );
-  return discovered;
-}
-async function resolveAdapter(adapterPath, cwd, platformRoot) {
-  const discovered = await discoverAdapters(
-    platformRoot ?? cwd,
-    platformRoot && platformRoot !== cwd ? cwd : void 0
-  );
-  const basePkgName = adapterPath.split("/").slice(0, 2).join("/");
-  const subpath = adapterPath.includes("/") ? adapterPath.split("/").slice(2).join("/") : null;
-  const adapter = discovered.get(basePkgName);
-  if (adapter && subpath) {
-    const subpathFile = path13__namespace.default.join(adapter.pkgRoot, "dist", `${subpath}.js`);
-    try {
-      await fs5.promises.access(subpathFile);
-      const module = await loadAdapterModule(subpathFile);
-      if (typeof module.createAdapter === "function") {
-        return module.createAdapter;
-      }
-      if (typeof module.default === "function") {
-        return module.default;
-      }
-    } catch {
-    }
-  } else if (adapter) {
-    return adapter.createAdapter;
-  }
-  return null;
-}
-var init_discover_adapters = __esm3({
-  "src/discover-adapters.ts"() {
-  }
-});
-var TransportError2;
-var TimeoutError4;
-var init_transport = __esm3({
-  "src/transport/transport.ts"() {
-    TransportError2 = class extends Error {
-      cause;
-      constructor(message2, cause) {
-        super(message2);
-        this.name = "TransportError";
-        this.cause = cause;
-        if (cause) {
-          this.stack = `${this.stack}
-Caused by: ${cause.stack}`;
-        }
-      }
-    };
-    TimeoutError4 = class extends TransportError2 {
-      timeoutMs;
-      constructor(message2, timeoutMs) {
-        super(message2);
-        this.name = "TimeoutError";
-        this.timeoutMs = timeoutMs;
-      }
-    };
-  }
-});
-function getOperationTimeout2(adapter, method) {
-  const exactKey = `${adapter}.${method}`;
-  if (exactKey in OPERATION_TIMEOUTS2) {
-    return OPERATION_TIMEOUTS2[exactKey];
-  }
-  const wildcardKey = `${adapter}.*`;
-  if (wildcardKey in OPERATION_TIMEOUTS2) {
-    return OPERATION_TIMEOUTS2[wildcardKey];
-  }
-  return OPERATION_TIMEOUTS2["*"];
-}
-function selectTimeout2(call, configTimeout) {
-  if (call.timeout !== void 0) {
-    return call.timeout;
-  }
-  if (configTimeout !== void 0) {
-    return configTimeout;
-  }
-  return getOperationTimeout2(call.adapter, call.method);
-}
-var OPERATION_TIMEOUTS2;
-var init_timeout_config = __esm3({
-  "src/transport/timeout-config.ts"() {
-    OPERATION_TIMEOUTS2 = {
-      // === VectorStore operations ===
-      // Bulk upsert is slow (Qdrant indexing overhead)
-      "vectorStore.upsert": 12e4,
-      // 2 minutes
-      // Search operations - medium latency
-      "vectorStore.search": 3e4,
-      // 30 seconds
-      "vectorStore.hybridSearch": 45e3,
-      // 45 seconds (BM25 + vector)
-      // Bulk retrieval - potentially large result sets
-      "vectorStore.get": 12e4,
-      // 2 minutes (retrieving many vectors)
-      "vectorStore.query": 12e4,
-      // 2 minutes (metadata filtering + retrieval)
-      // Collection management - fast
-      "vectorStore.createCollection": 15e3,
-      "vectorStore.deleteCollection": 15e3,
-      "vectorStore.collectionExists": 5e3,
-      // === Embeddings operations ===
-      // Single embed - OpenAI API latency
-      "embeddings.embed": 3e4,
-      // 30 seconds
-      // Batch embeddings - OpenAI processes in parallel, but may rate limit
-      "embeddings.embedBatch": 12e4,
-      // 2 minutes
-      // Dimension check - fast property access
-      "embeddings.getDimensions": 5e3,
-      // === LLM operations ===
-      // Text generation - depends on output length
-      "llm.generate": 9e4,
-      // 1.5 minutes
-      "llm.generateStream": 12e4,
-      // 2 minutes (streaming may take longer)
-      // === Cache operations ===
-      // Cache is fast (Redis or in-memory)
-      "cache.get": 5e3,
-      "cache.set": 5e3,
-      "cache.delete": 5e3,
-      "cache.clear": 1e4,
-      "cache.has": 5e3,
-      // === Storage operations ===
-      // File I/O - medium latency
-      "storage.read": 15e3,
-      "storage.write": 3e4,
-      "storage.delete": 1e4,
-      "storage.exists": 5e3,
-      "storage.list": 2e4,
-      // === Wildcard defaults ===
-      // Default timeout for any vectorStore operation not listed above
-      "vectorStore.*": 6e4,
-      // Default timeout for any embeddings operation
-      "embeddings.*": 6e4,
-      // Default timeout for any LLM operation
-      "llm.*": 9e4,
-      // Default timeout for any cache operation
-      "cache.*": 1e4,
-      // Default timeout for any storage operation
-      "storage.*": 3e4,
-      // === Global fallback ===
-      // Used when no specific rule matches
-      "*": 3e4
-      // 30 seconds default
-    };
-  }
-});
-var unix_socket_transport_exports = {};
-__export3(unix_socket_transport_exports, {
-  UnixSocketTransport: () => UnixSocketTransport2,
-  createUnixSocketTransport: () => createUnixSocketTransport2
-});
-function createUnixSocketTransport2(config2) {
-  return new UnixSocketTransport2(config2);
-}
-var UnixSocketTransport2;
-var init_unix_socket_transport = __esm3({
-  "src/transport/unix-socket-transport.ts"() {
-    init_transport();
-    init_timeout_config();
-    UnixSocketTransport2 = class {
-      constructor(config2 = {}) {
-        this.config = config2;
-      }
-      config;
-      socket = null;
-      pending = /* @__PURE__ */ new Map();
-      closed = false;
-      connecting = false;
-      buffer = "";
-      reconnectAttempts = 0;
-      /**
-       * Connect to Unix socket server.
-       * Called lazily on first send() or explicitly.
-       */
-      async connect() {
-        if (this.socket && !this.socket.destroyed) {
-          return;
-        }
-        if (this.connecting) {
-          await new Promise((resolve32) => {
-            setTimeout(resolve32, 100);
-          });
-          return this.connect();
-        }
-        this.connecting = true;
-        return new Promise((resolve32, reject) => {
-          const socketPath = this.config.socketPath ?? "/tmp/kb-ipc.sock";
-          this.socket = net__namespace.connect(socketPath);
-          this.socket.on("connect", () => {
-            this.connecting = false;
-            this.reconnectAttempts = 0;
-            resolve32();
-          });
-          this.socket.on("error", (error2) => {
-            this.connecting = false;
-            const maxAttempts = this.config.maxReconnectAttempts ?? 3;
-            if (this.config.autoReconnect !== false && this.reconnectAttempts < maxAttempts) {
-              this.reconnectAttempts++;
-              setTimeout(() => this.connect(), 1e3 * this.reconnectAttempts);
-              return;
-            }
-            reject(new TransportError2(`Unix socket connection failed: ${error2.message}`, error2));
-          });
-          this.socket.on("data", (data) => {
-            this.handleData(data);
-          });
-          this.socket.on("close", () => {
-            if (!this.closed && this.config.autoReconnect !== false) {
-              setTimeout(() => this.connect(), 1e3);
-            }
-          });
-        });
-      }
-      async send(call) {
-        if (this.closed) {
-          throw new TransportError2("Transport is closed");
-        }
-        await this.connect();
-        if (!this.socket || this.socket.destroyed) {
-          throw new TransportError2("Socket not available");
-        }
-        const timeout = selectTimeout2(call, this.config.timeout);
-        return new Promise((resolve32, reject) => {
-          const timer = setTimeout(() => {
-            this.pending.delete(call.requestId);
-            reject(new TimeoutError4(`Adapter call timed out after ${timeout}ms`, timeout));
-          }, timeout);
-          this.pending.set(call.requestId, { resolve: resolve32, reject, timer });
-          const message2 = JSON.stringify(call) + "\n";
-          const written = this.socket.write(message2, "utf8", (error2) => {
-            if (error2) {
-              const pending = this.pending.get(call.requestId);
-              if (pending) {
-                clearTimeout(pending.timer);
-                this.pending.delete(call.requestId);
-                reject(new TransportError2(`Failed to write to socket: ${error2.message}`, error2));
-              }
-            }
-          });
-          if (!written) {
-            this.socket.once("drain", () => {
-            });
-          }
-        });
-      }
-      /**
-       * Handle incoming data from Unix socket.
-       * Messages are newline-delimited JSON.
-       */
-      handleData(data) {
-        this.buffer += data.toString("utf8");
-        let newlineIndex;
-        while ((newlineIndex = this.buffer.indexOf("\n")) !== -1) {
-          const line = this.buffer.slice(0, newlineIndex);
-          this.buffer = this.buffer.slice(newlineIndex + 1);
-          if (line.trim().length === 0) {
-            continue;
-          }
-          try {
-            const msg = JSON.parse(line);
-            this.handleMessage(msg);
-          } catch {
-          }
-        }
-      }
-      handleMessage(msg) {
-        if (!isAdapterResponse(msg)) {
-          return;
-        }
-        const pending = this.pending.get(msg.requestId);
-        if (!pending) {
-          return;
-        }
-        clearTimeout(pending.timer);
-        this.pending.delete(msg.requestId);
-        pending.resolve(msg);
-      }
-      async close() {
-        if (this.closed) {
-          return;
-        }
-        this.closed = true;
-        if (this.socket) {
-          this.socket.destroy();
-          this.socket = null;
-        }
-        for (const [requestId, pending] of this.pending) {
-          clearTimeout(pending.timer);
-          pending.reject(new TransportError2("Transport closed"));
-        }
-        this.pending.clear();
-      }
-      isClosed() {
-        return this.closed;
-      }
-    };
-  }
-});
-var RemoteAdapter2;
-var init_remote_adapter = __esm3({
-  "src/proxy/remote-adapter.ts"() {
-    RemoteAdapter2 = class {
-      /**
-       * 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, transport, context) {
-        this.adapterName = adapterName;
-        this.transport = transport;
-        this.context = context;
-      }
-      adapterName;
-      transport;
-      context;
-      /**
-       * 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) {
-        this.context = context;
-      }
-      /**
-       * Get current execution context.
-       */
-      getContext() {
-        return this.context;
-      }
-      /**
-       * 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
-       * ```
-       */
-      async callRemote(method, args, timeout) {
-        const requestId = crypto4.randomUUID();
-        const call = {
-          version: IPC_PROTOCOL_VERSION,
-          // Protocol version for backward compatibility
-          type: "adapter:call",
-          requestId,
-          adapter: this.adapterName,
-          method,
-          args: args.map((arg) => serialize(arg)),
-          timeout,
-          // Optional timeout for this specific call
-          context: this.context
-          // Include execution context for tracing/debugging
-        };
-        const response = await this.transport.send(call);
-        if (response.error) {
-          throw deserialize(response.error);
-        }
-        return response.result !== void 0 ? deserialize(response.result) : void 0;
-      }
-      /**
-       * Get the adapter name this proxy represents.
-       */
-      getAdapterName() {
-        return this.adapterName;
-      }
-      /**
-       * Get the transport used by this proxy.
-       * Useful for advanced use cases (e.g., checking if transport is closed).
-       */
-      getTransport() {
-        return this.transport;
-      }
-    };
-  }
-});
-var BulkTransferHelper2;
-var init_bulk_transfer = __esm3({
-  "src/transport/bulk-transfer.ts"() {
-    BulkTransferHelper2 = class _BulkTransferHelper2 {
-      /** Map of temp file IDs to file paths (for cleanup) */
-      static tempFiles = /* @__PURE__ */ new Map();
-      /** Default options */
-      static defaultOptions = {
-        maxInlineSize: 1e6,
-        // 1MB
-        tempDir: os4.tmpdir()
-      };
-      /**
-       * Serialize data: inline for small, temp file for large
-       *
-       * @example
-       * ```typescript
-       * const transfer = await BulkTransferHelper.serialize(vectors, {
-       *   maxInlineSize: 1_000_000,
-       *   tempDir: '/tmp'
-       * });
-       *
-       * if (transfer.type === 'inline') {
-       *   console.log('Using inline IPC');
-       * } else {
-       *   console.log('Using temp file:', transfer.payload); // Absolute path like '/tmp/bulk-123.json'
-       * }
-       * ```
-       */
-      static async serialize(data, options = {}) {
-        const opts = { ...this.defaultOptions, ...options };
-        const json3 = JSON.stringify(data);
-        if (json3.length < opts.maxInlineSize) {
-          return { type: "inline", payload: json3 };
-        }
-        const tempId = `bulk-${Date.now()}-${Math.random().toString(36).slice(2)}`;
-        const tempPath = path13.join(opts.tempDir, `${tempId}.json`);
-        await fs2.writeFile(tempPath, json3, "utf8");
-        this.tempFiles.set(tempPath, tempPath);
-        return { type: "file", payload: tempPath };
-      }
-      /**
-       * Deserialize from inline JSON or temp file
-       *
-       * @example
-       * ```typescript
-       * const transfer = { type: 'file', payload: '/tmp/bulk-123.json' };
-       * const data = await BulkTransferHelper.deserialize<VectorRecord[]>(transfer);
-       * ```
-       */
-      static async deserialize(transfer) {
-        if (transfer.type === "inline") {
-          return JSON.parse(transfer.payload);
-        }
-        const tempPath = transfer.payload;
-        try {
-          const json3 = await fs2.readFile(tempPath, "utf8");
-          return JSON.parse(json3);
-        } finally {
-          await fs2.unlink(tempPath).catch(() => {
-          });
-          this.tempFiles.delete(tempPath);
-        }
-      }
-      /**
-       * Check if object is a BulkTransfer
-       */
-      static isBulkTransfer(obj) {
-        return typeof obj === "object" && obj !== null && "type" in obj && "payload" in obj && (obj.type === "inline" || obj.type === "file");
-      }
-      /**
-       * Cleanup all temp files (call on process exit)
-       */
-      static async cleanup() {
-        const cleanupPromises = Array.from(this.tempFiles.values()).map(
-          (path62) => fs2.unlink(path62).catch(() => {
-          })
-        );
-        await Promise.all(cleanupPromises);
-        this.tempFiles.clear();
-      }
-      /**
-       * Get statistics about temp files
-       */
-      static getStats() {
-        return {
-          tempFilesCount: this.tempFiles.size,
-          tempFilePaths: Array.from(this.tempFiles.values())
-        };
-      }
-      static registerSignalHandlers() {
-        process.on("SIGINT", async () => {
-          await _BulkTransferHelper2.cleanup();
-          process.exit(0);
-        });
-        process.on("SIGTERM", async () => {
-          await _BulkTransferHelper2.cleanup();
-          process.exit(0);
-        });
-        process.on("uncaughtException", async (error2) => {
-          console.error("[BulkTransferHelper] Uncaught exception, cleaning up temp files:", error2);
-          await _BulkTransferHelper2.cleanup();
-          process.exit(1);
-        });
-      }
-    };
-    process.on("exit", () => {
-      for (const path62 of BulkTransferHelper2.getStats().tempFilePaths) {
-        try {
-          fs5.unlinkSync(path62);
-        } catch {
-        }
-      }
-    });
-  }
-});
-var vector_store_proxy_exports = {};
-__export3(vector_store_proxy_exports, {
-  VectorStoreProxy: () => VectorStoreProxy2,
-  createVectorStoreProxy: () => createVectorStoreProxy
-});
-function createVectorStoreProxy(transport) {
-  return new VectorStoreProxy2(transport);
-}
-var VectorStoreProxy2;
-var init_vector_store_proxy = __esm3({
-  "src/proxy/vector-store-proxy.ts"() {
-    init_remote_adapter();
-    init_bulk_transfer();
-    VectorStoreProxy2 = class _VectorStoreProxy2 extends RemoteAdapter2 {
-      // Timeout for bulk operations that may trigger IPC backpressure
-      static BULK_OPERATION_TIMEOUT = 12e4;
-      // 2 minutes
-      // BulkTransfer configuration
-      bulkTransferOptions = {
-        maxInlineSize: 1e6,
-        // 1MB threshold
-        tempDir: process.env.KB_TEMP_DIR ?? os4.tmpdir()
-      };
-      /**
-       * Create a vector store proxy.
-       *
-       * @param transport - IPC transport to communicate with parent
-       */
-      constructor(transport) {
-        super("vectorStore", transport);
-      }
-      /**
-       * 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
-       */
-      async search(query, limit, filter2, namespace) {
-        return await this.callRemote("search", [query, limit, filter2, namespace]);
-      }
-      /**
-       * Insert or update vectors.
-       * Uses BulkTransfer for large payloads to avoid IPC backpressure.
-       *
-       * @param vectors - Vector records to upsert
-       */
-      async upsert(vectors, namespace) {
-        const transfer = await BulkTransferHelper2.serialize(vectors, this.bulkTransferOptions);
-        await this.callRemote("upsert", [transfer, namespace], _VectorStoreProxy2.BULK_OPERATION_TIMEOUT);
-      }
-      /**
-       * Delete vectors by IDs.
-       * Uses extended timeout for bulk deletions.
-       *
-       * @param ids - Vector IDs to delete
-       */
-      async delete(ids, namespace) {
-        await this.callRemote("delete", [ids, namespace], _VectorStoreProxy2.BULK_OPERATION_TIMEOUT);
-      }
-      /**
-       * 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
-       */
-      async upsertChunks(scope, vectors) {
-        await this.callRemote("upsertChunks", [scope, vectors], _VectorStoreProxy2.BULK_OPERATION_TIMEOUT);
-      }
-      /**
-       * Count total vectors in collection.
-       *
-       * @returns Promise resolving to vector count
-       */
-      async count(namespace) {
-        return await this.callRemote("count", [namespace]);
-      }
-      /**
-       * 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
-       */
-      async get(ids, namespace) {
-        const resultTransfer = await this.callRemote("get", [ids, namespace], _VectorStoreProxy2.BULK_OPERATION_TIMEOUT);
-        if (BulkTransferHelper2.isBulkTransfer(resultTransfer)) {
-          return BulkTransferHelper2.deserialize(resultTransfer);
-        }
-        return resultTransfer;
-      }
-      /**
-       * 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
-       */
-      async query(filter2, namespace) {
-        const resultTransfer = await this.callRemote("query", [filter2, namespace], _VectorStoreProxy2.BULK_OPERATION_TIMEOUT);
-        if (BulkTransferHelper2.isBulkTransfer(resultTransfer)) {
-          return BulkTransferHelper2.deserialize(resultTransfer);
-        }
-        return resultTransfer;
-      }
-      /**
-       * Clear all vectors from collection.
-       * Uses extended timeout for bulk deletion.
-       */
-      async clear() {
-        await this.callRemote("clear", [], _VectorStoreProxy2.BULK_OPERATION_TIMEOUT);
-      }
-      /**
-       * Initialize the vector store.
-       * Called during platform initialization.
-       */
-      async initialize() {
-        await this.callRemote("initialize", []);
-      }
-      /**
-       * Close connections and cleanup resources.
-       */
-      async close() {
-        await this.callRemote("close", []);
-      }
-    };
-  }
-});
-var cache_proxy_exports = {};
-__export3(cache_proxy_exports, {
-  CacheProxy: () => CacheProxy2,
-  createCacheProxy: () => createCacheProxy
-});
-function createCacheProxy(transport) {
-  return new CacheProxy2(transport);
-}
-var CacheProxy2;
-var init_cache_proxy = __esm3({
-  "src/proxy/cache-proxy.ts"() {
-    init_remote_adapter();
-    CacheProxy2 = class extends RemoteAdapter2 {
-      /**
-       * Create a cache proxy.
-       *
-       * @param transport - IPC transport to communicate with parent
-       */
-      constructor(transport) {
-        super("cache", transport);
-      }
-      /**
-       * Get a value from cache.
-       *
-       * @param key - Cache key
-       * @returns Cached value or null if not found/expired
-       */
-      async get(key) {
-        return await this.callRemote("get", [key]);
-      }
-      /**
-       * Set a value in cache.
-       *
-       * @param key - Cache key
-       * @param value - Value to cache
-       * @param ttl - Time to live in milliseconds (optional)
-       */
-      async set(key, value, ttl) {
-        await this.callRemote("set", [key, value, ttl]);
-      }
-      /**
-       * Delete a value from cache.
-       *
-       * @param key - Cache key
-       */
-      async delete(key) {
-        await this.callRemote("delete", [key]);
-      }
-      /**
-       * Clear cache entries matching a pattern.
-       *
-       * @param pattern - Glob pattern (e.g., 'user:*')
-       */
-      async clear(pattern) {
-        await this.callRemote("clear", [pattern]);
-      }
-      /**
-       * Add member to sorted set with score.
-       *
-       * @param key - Sorted set key
-       * @param score - Numeric score (typically timestamp)
-       * @param member - Member to add
-       */
-      async zadd(key, score, member) {
-        await this.callRemote("zadd", [key, score, member]);
-      }
-      /**
-       * 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
-       */
-      async zrangebyscore(key, min, max) {
-        return await this.callRemote("zrangebyscore", [key, min, max]);
-      }
-      /**
-       * Remove member from sorted set.
-       *
-       * @param key - Sorted set key
-       * @param member - Member to remove
-       */
-      async zrem(key, member) {
-        await this.callRemote("zrem", [key, member]);
-      }
-      /**
-       * 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
-       */
-      async setIfNotExists(key, value, ttl) {
-        return await this.callRemote("setIfNotExists", [key, value, ttl]);
-      }
-    };
-  }
-});
-var config_proxy_exports = {};
-__export3(config_proxy_exports, {
-  ConfigProxy: () => ConfigProxy2
-});
-var ConfigProxy2;
-var init_config_proxy = __esm3({
-  "src/proxy/config-proxy.ts"() {
-    init_remote_adapter();
-    ConfigProxy2 = class extends RemoteAdapter2 {
-      /**
-       * Create a config proxy.
-       *
-       * @param transport - IPC transport to communicate with parent
-       */
-      constructor(transport) {
-        super("config", transport);
-      }
-      /**
-       * Get product-specific configuration.
-       *
-       * @param productId - Product identifier (e.g., 'mind', 'workflow', 'plugins')
-       * @param profileId - Profile identifier (defaults to 'default' or KB_PROFILE env var)
-       * @returns Promise resolving to product-specific config or undefined
-       *
-       * @example
-       * ```typescript
-       * const mindConfig = await config.getConfig('mind');
-       * if (mindConfig?.scopes) {
-       *   // Use scopes
-       * }
-       * ```
-       */
-      async getConfig(productId, profileId) {
-        return this.callRemote("getConfig", [productId, profileId]);
-      }
-      /**
-       * Get raw kb.config.json data.
-       *
-       * @returns Promise resolving to raw config object or undefined
-       *
-       * @example
-       * ```typescript
-       * const rawConfig = await config.getRawConfig();
-       * if (rawConfig) {
-       *   const allProfiles = rawConfig.profiles;
-       * }
-       * ```
-       */
-      async getRawConfig() {
-        return this.callRemote("getRawConfig", []);
-      }
-    };
-  }
-});
-var llm_proxy_exports = {};
-__export3(llm_proxy_exports, {
-  LLMProxy: () => LLMProxy2,
-  createLLMProxy: () => createLLMProxy
-});
-function createLLMProxy(transport) {
-  return new LLMProxy2(transport);
-}
-var LLMProxy2;
-var init_llm_proxy = __esm3({
-  "src/proxy/llm-proxy.ts"() {
-    init_remote_adapter();
-    LLMProxy2 = class extends RemoteAdapter2 {
-      /**
-       * Create an LLM proxy.
-       *
-       * @param transport - IPC transport to communicate with parent
-       */
-      constructor(transport) {
-        super("llm", transport);
-      }
-      /**
-       * Generate a completion for the given prompt.
-       *
-       * @param prompt - Text prompt
-       * @param options - Optional generation options
-       * @returns LLM response with content and token usage
-       */
-      async complete(prompt, options) {
-        return await this.callRemote("complete", [prompt, options]);
-      }
-      getProtocolCapabilities() {
-        return {
-          cache: { supported: false },
-          stream: { supported: false }
-        };
-      }
-      /**
-       * 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()
-       */
-      async *stream(prompt, options) {
-        console.warn("[LLMProxy] stream() fallback via complete() over IPC.");
-        const response = await this.complete(prompt, options);
-        if (response.content) {
-          yield response.content;
-        }
-      }
-      /**
-       * 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
-       */
-      async chatWithTools(messages, options) {
-        return await this.callRemote("chatWithTools", [messages, options]);
-      }
-    };
-  }
-});
-var embeddings_proxy_exports = {};
-__export3(embeddings_proxy_exports, {
-  EmbeddingsProxy: () => EmbeddingsProxy2,
-  createEmbeddingsProxy: () => createEmbeddingsProxy
-});
-function createEmbeddingsProxy(transport, dimensions) {
-  return new EmbeddingsProxy2(transport, dimensions);
-}
-var EmbeddingsProxy2;
-var init_embeddings_proxy = __esm3({
-  "src/proxy/embeddings-proxy.ts"() {
-    init_remote_adapter();
-    EmbeddingsProxy2 = class extends RemoteAdapter2 {
-      _dimensions;
-      /**
-       * Create an embeddings proxy.
-       *
-       * @param transport - IPC transport to communicate with parent
-       * @param dimensions - Optional dimensions override (avoids IPC call)
-       */
-      constructor(transport, dimensions) {
-        super("embeddings", transport);
-        this._dimensions = dimensions;
-      }
-      /**
-       * Generate embedding vector for a single text.
-       *
-       * @param text - Input text
-       * @returns Embedding vector
+      }
+      /**
+       * Get socket path for IPC communication.
+       * Returns undefined if not running in parent process.
        */
-      async embed(text) {
-        return await this.callRemote("embed", [text]);
+      getSocketPath() {
+        return this._socketServer?.getSocketPath();
       }
       /**
-       * Generate embedding vectors for multiple texts.
+       * Initialize execution backend.
+       * Called internally by initPlatform() AFTER adapters, BEFORE core features.
        *
-       * @param texts - Array of input texts
-       * @returns Array of embedding vectors (same order as input)
+       * @param backend - ExecutionBackend instance (from @kb-labs/plugin-execution)
        */
-      async embedBatch(texts) {
-        return await this.callRemote("embedBatch", [texts]);
+      initExecutionBackend(backend) {
+        if (this._executionBackend) {
+          this.logger.warn("ExecutionBackend already initialized, replacing");
+        }
+        this._executionBackend = backend;
+        this.logger.debug("ExecutionBackend initialized", {
+          mode: backend.constructor.name
+        });
       }
       /**
-       * Dimension of the embedding vectors.
+       * Get execution backend.
+       * Returns the initialized backend or throws if not initialized.
        *
-       * This value is fetched once from the parent on first access
-       * and cached locally for performance.
+       * @throws Error if ExecutionBackend not initialized via initPlatform()
+       * @returns ExecutionBackend instance
        */
-      get dimensions() {
-        if (this._dimensions === void 0) {
+      get executionBackend() {
+        if (!this._executionBackend) {
           throw new Error(
-            "EmbeddingsProxy dimensions not initialized. Call getDimensions() first or pass dimensions to constructor."
+            "ExecutionBackend not initialized. Call initPlatform() with execution config to initialize ExecutionBackend."
           );
         }
-        return this._dimensions;
+        return this._executionBackend;
       }
       /**
-       * 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
-       * ```
+       * Check if execution backend is initialized.
        */
-      async getDimensions() {
-        if (this._dimensions === void 0) {
-          this._dimensions = await this.callRemote("getDimensions", []);
-        }
-        return this._dimensions;
+      get hasExecutionBackend() {
+        return !!this._executionBackend;
       }
-    };
-  }
-});
-var storage_proxy_exports = {};
-__export3(storage_proxy_exports, {
-  StorageProxy: () => StorageProxy2,
-  createStorageProxy: () => createStorageProxy
-});
-function createStorageProxy(transport) {
-  return new StorageProxy2(transport);
-}
-var StorageProxy2;
-var init_storage_proxy = __esm3({
-  "src/proxy/storage-proxy.ts"() {
-    init_remote_adapter();
-    StorageProxy2 = class extends RemoteAdapter2 {
       /**
-       * Create a storage proxy.
-       *
-       * @param transport - IPC transport to communicate with parent
+       * Initialize orchestration services.
+       * Called internally by initPlatform() after ExecutionBackend init.
        */
-      constructor(transport) {
-        super("storage", transport);
+      initOrchestrationServices(environmentManager, runExecutor, runOrchestrator) {
+        this._environmentManager = environmentManager;
+        this._runExecutor = runExecutor;
+        this._runOrchestrator = runOrchestrator;
       }
       /**
-       * Read file contents.
-       *
-       * @param path - File path
-       * @returns File contents or null if not found
+       * Initialize infrastructure capability services.
+       * Called internally by initPlatform().
        */
-      async read(path62) {
-        return await this.callRemote("read", [path62]);
+      initCapabilityServices(workspaceManager, snapshotManager) {
+        this._workspaceManager = workspaceManager;
+        this._snapshotManager = snapshotManager;
       }
       /**
-       * Write file contents.
-       *
-       * @param path - File path
-       * @param data - File contents
+       * Environment manager service.
+       * Returns undefined when not initialized (e.g., proxy/minimal platforms).
        */
-      async write(path62, data) {
-        await this.callRemote("write", [path62, data]);
+      get environmentManager() {
+        return this._environmentManager;
       }
       /**
-       * Delete a file.
-       *
-       * @param path - File path
+       * Workspace manager service.
+       * Returns undefined when not initialized (e.g., proxy/minimal platforms).
        */
-      async delete(path62) {
-        await this.callRemote("delete", [path62]);
+      get workspaceManager() {
+        return this._workspaceManager;
       }
       /**
-       * List files matching a prefix.
-       *
-       * @param prefix - Path prefix (e.g., 'docs/')
-       * @returns Array of file paths
+       * Snapshot manager service.
+       * Returns undefined when not initialized (e.g., proxy/minimal platforms).
        */
-      async list(prefix) {
-        return await this.callRemote("list", [prefix]);
+      get snapshotManager() {
+        return this._snapshotManager;
       }
       /**
-       * Check if a file exists.
-       *
-       * @param path - File path
-       * @returns True if file exists, false otherwise
+       * Run executor service.
        */
-      async exists(path62) {
-        return await this.callRemote("exists", [path62]);
+      get runExecutor() {
+        if (!this._runExecutor) {
+          throw new Error("RunExecutor not initialized. Call initPlatform() first.");
+        }
+        return this._runExecutor;
       }
-      // ═══════════════════════════════════════════════════════════════════════
-      // EXTENDED METHODS (optional - implements IStorage extended interface)
-      // ═══════════════════════════════════════════════════════════════════════
       /**
-       * Get file metadata.
-       * Optional method - implements IStorage.stat().
-       *
-       * @param path - File path
-       * @returns File metadata or null if not found
+       * Run orchestrator service.
        */
-      async stat(path62) {
-        return await this.callRemote("stat", [path62]);
+      get runOrchestrator() {
+        if (!this._runOrchestrator) {
+          throw new Error(
+            "RunOrchestrator not initialized. Call initPlatform() first."
+          );
+        }
+        return this._runOrchestrator;
       }
       /**
-       * Copy file within storage.
-       * Optional method - implements IStorage.copy().
-       *
-       * @param sourcePath - Source file path
-       * @param destPath - Destination file path
+       * Check if platform is initialized.
        */
-      async copy(sourcePath, destPath) {
-        await this.callRemote("copy", [sourcePath, destPath]);
+      get isInitialized() {
+        return this.initialized;
       }
       /**
-       * Move file within storage.
-       * Optional method - implements IStorage.move().
-       *
-       * @param sourcePath - Source file path
-       * @param destPath - Destination file path
+       * Reset platform to initial state.
+       * Clears all adapters and core features.
+       * Used primarily for testing.
        */
-      async move(sourcePath, destPath) {
-        await this.callRemote("move", [sourcePath, destPath]);
+      reset() {
+        this.adapters.clear();
+        this.adapters.set("logger", new ConsoleLogger());
+        this.lifecycleHooks.clear();
+        this._workflows = void 0;
+        this._jobs = void 0;
+        this._cron = void 0;
+        this._resources = void 0;
+        this._resourceBroker = void 0;
+        this._socketServer = void 0;
+        this._executionBackend = void 0;
+        this._environmentManager = void 0;
+        this._workspaceManager = void 0;
+        this._snapshotManager = void 0;
+        this._runExecutor = void 0;
+        this._runOrchestrator = void 0;
+        this.initialized = false;
+        this.assembled = false;
       }
       /**
-       * List files with metadata.
-       * Optional method - implements IStorage.listWithMetadata().
-       *
-       * @param prefix - Path prefix (e.g., 'docs/')
-       * @returns Array of file metadata
+       * Shutdown platform gracefully.
+       * Closes all resources, stops workers, cleanup.
        */
-      async listWithMetadata(prefix) {
-        return await this.callRemote("listWithMetadata", [prefix]);
+      async shutdown() {
+        await this.emitLifecyclePhase("beforeShutdown", {
+          reason: "platform.shutdown",
+          metadata: {
+            adapterCount: this.adapters.size,
+            hasExecutionBackend: !!this._executionBackend
+          }
+        });
+        if (this._executionBackend) {
+          try {
+            await this._executionBackend.shutdown();
+          } catch (error2) {
+            this.logger.warn("ExecutionBackend shutdown failed", {
+              error: error2 instanceof Error ? error2.message : String(error2)
+            });
+          }
+        }
+        if (this._environmentManager) {
+          try {
+            await this._environmentManager.shutdown();
+          } catch (error2) {
+            this.logger.warn("EnvironmentManager shutdown failed", {
+              error: error2 instanceof Error ? error2.message : String(error2)
+            });
+          }
+        }
+        if (this._workspaceManager) {
+          try {
+            await this._workspaceManager.shutdown();
+          } catch (error2) {
+            this.logger.warn("WorkspaceManager shutdown failed", {
+              error: error2 instanceof Error ? error2.message : String(error2)
+            });
+          }
+        }
+        if (this._snapshotManager) {
+          try {
+            await this._snapshotManager.shutdown();
+          } catch (error2) {
+            this.logger.warn("SnapshotManager shutdown failed", {
+              error: error2 instanceof Error ? error2.message : String(error2)
+            });
+          }
+        }
+        const adaptersInReverseLoadOrder = Array.from(this.adapters.entries()).reverse();
+        for (const [adapterId, adapter] of adaptersInReverseLoadOrder) {
+          if (!adapter || adapter === this._executionBackend) {
+            continue;
+          }
+          const candidate = adapter;
+          try {
+            if (typeof candidate.close === "function") {
+              await candidate.close.call(adapter);
+            } else if (typeof candidate.dispose === "function") {
+              await candidate.dispose.call(adapter);
+            } else if (typeof candidate.shutdown === "function") {
+              await candidate.shutdown.call(adapter);
+            }
+          } catch (error2) {
+            this.logger.warn("Adapter shutdown failed", {
+              adapterId,
+              error: error2 instanceof Error ? error2.message : String(error2)
+            });
+          }
+        }
+        await this.emitLifecyclePhase("shutdown", {
+          reason: "platform.shutdown",
+          metadata: {
+            adapterCount: this.adapters.size
+          }
+        });
       }
     };
+    PLATFORM_SINGLETON_KEY = /* @__PURE__ */ Symbol.for("kb.platform");
+    platform = (() => {
+      const existing = getPlatformFromProcess();
+      if (existing && typeof existing.setAdapter === "function" && typeof existing.getAdapter === "function") {
+        return existing;
+      }
+      const newPlatform = new PlatformContainer();
+      setPlatformInProcess(newPlatform);
+      return newPlatform;
+    })();
+  }
+});
+var discover_adapters_exports = {};
+__export3(discover_adapters_exports, {
+  discoverAdapters: () => discoverAdapters,
+  resolveAdapter: () => resolveAdapter
+});
+async function loadAdapterModule(distPath) {
+  const fileUrl = url$1.pathToFileURL(distPath).href;
+  return import(fileUrl);
+}
+async function loadAdaptersFromLock(root, discovered, overwrite) {
+  const diag2 = new DiagnosticCollector();
+  const lock = await readMarketplaceLock(root, diag2);
+  if (!lock) {
+    return;
+  }
+  for (const [pkgId, entry] of Object.entries(lock.installed)) {
+    if (entry.primaryKind !== "adapter") {
+      continue;
+    }
+    if (entry.enabled === false) {
+      continue;
+    }
+    const pkgRoot = path13__namespace.default.resolve(root, entry.resolvedPath);
+    let mainPath = "dist/index.js";
+    let npmPkgName;
+    try {
+      const pkgContent = await fs5.promises.readFile(path13__namespace.default.join(pkgRoot, "package.json"), "utf-8");
+      const pkg = JSON.parse(pkgContent);
+      mainPath = pkg.main || mainPath;
+      npmPkgName = pkg.name;
+    } catch {
+    }
+    const distPath = path13__namespace.default.join(pkgRoot, mainPath);
+    try {
+      await fs5.promises.access(distPath);
+      const module = await loadAdapterModule(distPath);
+      if (typeof module.createAdapter !== "function") {
+        continue;
+      }
+      const adapterEntry = {
+        packageName: npmPkgName ?? pkgId,
+        pkgRoot,
+        createAdapter: module.createAdapter,
+        module
+      };
+      if (overwrite || !discovered.has(pkgId)) {
+        discovered.set(pkgId, adapterEntry);
+      }
+      if (npmPkgName && npmPkgName !== pkgId) {
+        if (overwrite || !discovered.has(npmPkgName)) {
+          discovered.set(npmPkgName, adapterEntry);
+        }
+      }
+    } catch {
+    }
+  }
+}
+async function discoverAdapters(platformRoot, projectRoot) {
+  const discovered = /* @__PURE__ */ new Map();
+  if (projectRoot && projectRoot !== platformRoot) {
+    await loadAdaptersFromLock(
+      projectRoot,
+      discovered,
+      /* overwrite= */
+      true
+    );
+  }
+  await loadAdaptersFromLock(
+    platformRoot,
+    discovered,
+    /* overwrite= */
+    false
+  );
+  return discovered;
+}
+async function resolveAdapter(adapterPath, cwd, platformRoot) {
+  const discovered = await discoverAdapters(
+    platformRoot ?? cwd,
+    platformRoot && platformRoot !== cwd ? cwd : void 0
+  );
+  const basePkgName = adapterPath.split("/").slice(0, 2).join("/");
+  const subpath = adapterPath.includes("/") ? adapterPath.split("/").slice(2).join("/") : null;
+  const adapter = discovered.get(basePkgName);
+  if (adapter && subpath) {
+    const subpathFile = path13__namespace.default.join(adapter.pkgRoot, "dist", `${subpath}.js`);
+    try {
+      await fs5.promises.access(subpathFile);
+      const module = await loadAdapterModule(subpathFile);
+      if (typeof module.createAdapter === "function") {
+        return module.createAdapter;
+      }
+      if (typeof module.default === "function") {
+        return module.default;
+      }
+    } catch {
+    }
+  } else if (adapter) {
+    return adapter.createAdapter;
+  }
+  return null;
+}
+var init_discover_adapters = __esm3({
+  "src/discover-adapters.ts"() {
   }
 });
 var config_adapter_exports = {};
@@ -81545,6 +80602,122 @@ var init_config_adapter = __esm3({
     };
   }
 });
+var BulkTransferHelper2;
+var init_bulk_transfer = __esm3({
+  "src/transport/bulk-transfer.ts"() {
+    BulkTransferHelper2 = class _BulkTransferHelper2 {
+      /** Map of temp file IDs to file paths (for cleanup) */
+      static tempFiles = /* @__PURE__ */ new Map();
+      /** Default options */
+      static defaultOptions = {
+        maxInlineSize: 1e6,
+        // 1MB
+        tempDir: os4.tmpdir()
+      };
+      /**
+       * Serialize data: inline for small, temp file for large
+       *
+       * @example
+       * ```typescript
+       * const transfer = await BulkTransferHelper.serialize(vectors, {
+       *   maxInlineSize: 1_000_000,
+       *   tempDir: '/tmp'
+       * });
+       *
+       * if (transfer.type === 'inline') {
+       *   console.log('Using inline IPC');
+       * } else {
+       *   console.log('Using temp file:', transfer.payload); // Absolute path like '/tmp/bulk-123.json'
+       * }
+       * ```
+       */
+      static async serialize(data, options = {}) {
+        const opts = { ...this.defaultOptions, ...options };
+        const json3 = JSON.stringify(data);
+        if (json3.length < opts.maxInlineSize) {
+          return { type: "inline", payload: json3 };
+        }
+        const tempId = `bulk-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+        const tempPath = path13.join(opts.tempDir, `${tempId}.json`);
+        await fs2.writeFile(tempPath, json3, "utf8");
+        this.tempFiles.set(tempPath, tempPath);
+        return { type: "file", payload: tempPath };
+      }
+      /**
+       * Deserialize from inline JSON or temp file
+       *
+       * @example
+       * ```typescript
+       * const transfer = { type: 'file', payload: '/tmp/bulk-123.json' };
+       * const data = await BulkTransferHelper.deserialize<VectorRecord[]>(transfer);
+       * ```
+       */
+      static async deserialize(transfer) {
+        if (transfer.type === "inline") {
+          return JSON.parse(transfer.payload);
+        }
+        const tempPath = transfer.payload;
+        try {
+          const json3 = await fs2.readFile(tempPath, "utf8");
+          return JSON.parse(json3);
+        } finally {
+          await fs2.unlink(tempPath).catch(() => {
+          });
+          this.tempFiles.delete(tempPath);
+        }
+      }
+      /**
+       * Check if object is a BulkTransfer
+       */
+      static isBulkTransfer(obj) {
+        return typeof obj === "object" && obj !== null && "type" in obj && "payload" in obj && (obj.type === "inline" || obj.type === "file");
+      }
+      /**
+       * Cleanup all temp files (call on process exit)
+       */
+      static async cleanup() {
+        const cleanupPromises = Array.from(this.tempFiles.values()).map(
+          (path62) => fs2.unlink(path62).catch(() => {
+          })
+        );
+        await Promise.all(cleanupPromises);
+        this.tempFiles.clear();
+      }
+      /**
+       * Get statistics about temp files
+       */
+      static getStats() {
+        return {
+          tempFilesCount: this.tempFiles.size,
+          tempFilePaths: Array.from(this.tempFiles.values())
+        };
+      }
+      static registerSignalHandlers() {
+        process.on("SIGINT", async () => {
+          await _BulkTransferHelper2.cleanup();
+          process.exit(0);
+        });
+        process.on("SIGTERM", async () => {
+          await _BulkTransferHelper2.cleanup();
+          process.exit(0);
+        });
+        process.on("uncaughtException", async (error2) => {
+          console.error("[BulkTransferHelper] Uncaught exception, cleaning up temp files:", error2);
+          await _BulkTransferHelper2.cleanup();
+          process.exit(1);
+        });
+      }
+    };
+    process.on("exit", () => {
+      for (const path62 of BulkTransferHelper2.getStats().tempFilePaths) {
+        try {
+          fs5.unlinkSync(path62);
+        } catch {
+        }
+      }
+    });
+  }
+});
 var unix_socket_server_exports = {};
 __export3(unix_socket_server_exports, {
   UnixSocketServer: () => UnixSocketServer2,
@@ -84218,35 +83391,37 @@ async function initPlatform(config2 = {}, cwd = process.cwd(), uiProvider, platf
   try {
     if (isChildProcess) {
       platform.logger.debug("initPlatform child process detected - creating proxy adapters");
-      const { UnixSocketTransport: UnixSocketTransport3 } = await Promise.resolve().then(() => (init_unix_socket_transport(), unix_socket_transport_exports));
-      const { VectorStoreProxy: VectorStoreProxy22 } = await Promise.resolve().then(() => (init_vector_store_proxy(), vector_store_proxy_exports));
-      const { CacheProxy: CacheProxy22 } = await Promise.resolve().then(() => (init_cache_proxy(), cache_proxy_exports));
-      const { ConfigProxy: ConfigProxy22 } = await Promise.resolve().then(() => (init_config_proxy(), config_proxy_exports));
-      const { LLMProxy: LLMProxy22 } = await Promise.resolve().then(() => (init_llm_proxy(), llm_proxy_exports));
-      const { EmbeddingsProxy: EmbeddingsProxy22 } = await Promise.resolve().then(() => (init_embeddings_proxy(), embeddings_proxy_exports));
-      const { StorageProxy: StorageProxy22 } = await Promise.resolve().then(() => (init_storage_proxy(), storage_proxy_exports));
+      const {
+        UnixSocketTransport: UnixSocketTransport3,
+        VectorStoreProxy: VectorStoreProxy2,
+        CacheProxy: CacheProxy2,
+        ConfigProxy: ConfigProxy2,
+        LLMProxy: LLMProxy2,
+        EmbeddingsProxy: EmbeddingsProxy2,
+        StorageProxy: StorageProxy2
+      } = await Promise.resolve().then(() => (init_dist5(), dist_exports));
       const transport = new UnixSocketTransport3();
       platform.logger.debug("initPlatform using Unix Socket transport");
       if (adapters.vectorStore) {
-        platform.setAdapter("vectorStore", new VectorStoreProxy22(transport));
+        platform.setAdapter("vectorStore", new VectorStoreProxy2(transport));
         platform.logger.debug("initPlatform created VectorStoreProxy");
       }
       if (adapters.cache) {
-        platform.setAdapter("cache", new CacheProxy22(transport));
+        platform.setAdapter("cache", new CacheProxy2(transport));
         platform.logger.debug("initPlatform created CacheProxy");
       }
-      platform.setAdapter("config", new ConfigProxy22(transport));
+      platform.setAdapter("config", new ConfigProxy2(transport));
       platform.logger.debug("initPlatform created ConfigProxy");
-      platform.setAdapter("llm", new LLMProxy22(transport));
+      platform.setAdapter("llm", new LLMProxy2(transport));
       platform.logger.debug("initPlatform created LLMProxy");
       if (adapters.embeddings) {
-        const embeddingsProxy = new EmbeddingsProxy22(transport);
+        const embeddingsProxy = new EmbeddingsProxy2(transport);
         await embeddingsProxy.getDimensions();
         platform.setAdapter("embeddings", embeddingsProxy);
         platform.logger.debug("initPlatform created EmbeddingsProxy");
       }
       if (adapters.storage) {
-        platform.setAdapter("storage", new StorageProxy22(transport));
+        platform.setAdapter("storage", new StorageProxy2(transport));
         platform.logger.debug("initPlatform created StorageProxy");
       }
       fillAdapterFallbacksAndRecord(
@@ -84941,6 +84116,47 @@ function interpolateConfig(value, required2 = true, env = process.env) {
   }
   return value;
 }
+function applyLocalNetworkOffset(value, env = process.env) {
+  const offset = Number(env.KB_NET_OFFSET) || 0;
+  if (offset === 0) {
+    return value;
+  }
+  return shiftConfigUrls(value, offset);
+}
+function shiftConfigUrls(value, offset) {
+  if (typeof value === "string") {
+    return shiftLoopbackUrl(value, offset);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => shiftConfigUrls(item, offset));
+  }
+  if (value === null || typeof value !== "object") {
+    return value;
+  }
+  const result = {};
+  for (const [key, child] of Object.entries(value)) {
+    result[key] = key === "serviceTransport" ? child : shiftConfigUrls(child, offset);
+  }
+  return result;
+}
+function shiftLoopbackUrl(value, offset) {
+  let url2;
+  try {
+    url2 = new URL(value);
+  } catch {
+    return value;
+  }
+  if (!["localhost", "127.0.0.1", "::1", "[::1]"].includes(url2.hostname) || !url2.port) {
+    return value;
+  }
+  const port = Number(url2.port);
+  if (!Number.isInteger(port) || port <= 0) {
+    return value;
+  }
+  url2.port = String(port + offset);
+  const shifted = url2.toString();
+  return /^[a-z][a-z0-9+.-]*:\/\/[^/?#]+$/i.test(value) ? shifted.replace(/\/$/, "") : shifted;
+}
 var PLATFORM_CONFIG_PRODUCT = "platform";
 var PLATFORM_CONFIG_SCHEMA = {
   type: "object",
@@ -85117,7 +84333,10 @@ async function loadPlatformConfig(options = {}) {
     );
   }
   const strictInterpolation = env.NODE_ENV === "production";
-  const effective = interpolateConfig(merged, strictInterpolation, env);
+  const effective = applyLocalNetworkOffset(
+    interpolateConfig(merged, strictInterpolation, env),
+    env
+  );
   return {
     platformConfig: effective,
     rawConfig: rawProjectConfig,
@@ -85549,21 +84768,7 @@ function createSilentLogger() {
     debug: noop
   };
 }
-init_remote_adapter();
-init_vector_store_proxy();
-init_cache_proxy();
-init_llm_proxy();
-init_embeddings_proxy();
-init_storage_proxy();
-init_remote_adapter();
-init_remote_adapter();
-init_unix_socket_transport();
-init_cache_proxy();
-init_llm_proxy();
-init_embeddings_proxy();
-init_vector_store_proxy();
-init_storage_proxy();
-init_remote_adapter();
+init_bulk_transfer();
 init_container();
 init_adapter_status();