yaml-flow 8.6.1 → 8.6.2

package/examples/board/server/board-server.js

@@ -11,12 +11,18 @@ import { fileURLToPath, pathToFileURL } from 'node:url';
 import {
   createMultiBoardServerRuntime,
   createSingleBoardServerRuntime,
+  createHostedBoardQueueLaneRegistry,
 } from 'yaml-flow/board-live-cards-server-runtime';
+import {
+  createHostedAsyncBoardPlatformAdapter,
+} from 'yaml-flow/cloud-storage';
 
 import {
   buildLocalBaseSpec,
+  createHttpBoardCallbackTransport,
   createFsBoardPlatformAdapter,
   createFsBoardNonCorePlatformAdapter,
+  createInProcessBoardCallbackTransport,
   createFsBoardChatStorage,
   createNodeSpawnInvocationAdapter,
   createArtifactsStore,
@@ -24,8 +30,9 @@ import {
   invokeExecutionRef,
   parseRef,
   registerInProcessExecutionHandler,
-  startBoardWorkerQueueRunner,
+  startQueueLaneRunners,
   serializeRef,
+  serializeExecutionRef,
 } from 'yaml-flow/board-live-cards-node';
 import { registerInProcessBoardWorkerCallback } from 'yaml-flow/board-worker-adapter';
 import {
@@ -144,6 +151,12 @@ const configuredChatFlowTimeoutMs = normalizeTimeoutMs(serverConfig.chatFlowTime
 const configuredInvokeRefTimeoutMs = normalizeTimeoutMs(serverConfig.chatInvokeRefTimeoutMs, 300000);
 const configuredCopilotTimeoutMs = normalizeTimeoutMs(serverConfig.chatCopilotTimeoutMs, 300000);
 
+function normalizeRuntimeMode(value) {
+  const normalized = String(value || '').trim().toLowerCase();
+  if (normalized === 'sync' || normalized === 'fs') return 'sync';
+  return 'cloud';
+}
+
 function normalizeBoardWorkerTransport(value) {
   const normalized = String(value || '').trim().toLowerCase();
   if (normalized === 'http') return 'http';
@@ -154,6 +167,9 @@ function normalizeBoardWorkerTransport(value) {
 const configuredBoardWorkerTransport = normalizeBoardWorkerTransport(
   process.env.DEMO_TASK_EXECUTOR_TRANSPORT || serverConfig.taskExecutorTransport || 'in-process-loop',
 );
+const configuredRuntimeMode = normalizeRuntimeMode(
+  process.env.DEMO_SERVER_MODE || serverConfig.mode || 'cloud',
+);
 
 // Resolve top-level config defaults (used as fallbacks for per-board config)
 const configuredTaskExecutorPath = resolveFromConfig(serverConfig.taskExecutorPath);
@@ -293,25 +309,14 @@ function makeHostedBoardWorkerRef(boardId, taskExecPath, transport, executionExt
   throw new Error(`Unsupported board-worker transport for demo host: ${transport}`);
 }
 
-function makeBoardWorkerCallbackSelfRef(serverUrl, boardApiBasePath, transport, boardId) {
-  if (transport === 'in-process-loop' || transport === 'queue') {
-    return {
-      meta: 'board-live-cards',
-      howToRun: 'in-process-loop',
-      whatToRun: serializeRef({ kind: 'in-process-loop', value: `board:${boardId}:board-worker-callback` }),
-    };
+function makeBoardWorkerCallbackTransport(serverUrl, boardApiBasePath, transport, boardId) {
+  if (transport === 'in-process-loop' || transport === 'queue' || transport === 'http') {
+    return createInProcessBoardCallbackTransport(`board:${boardId}:board-worker-callback`);
   }
   const normalizedServerUrl = typeof serverUrl === 'string' ? serverUrl.trim().replace(/\/+$/, '') : '';
   const normalizedApiBasePath = typeof boardApiBasePath === 'string' ? boardApiBasePath.trim().replace(/\/+$/, '') : '';
   if (!normalizedServerUrl || !normalizedApiBasePath) return undefined;
-  return {
-    meta: 'board-live-cards',
-    howToRun: 'http:post',
-    whatToRun: serializeRef({
-      kind: 'http-url',
-      value: `${normalizedServerUrl}${normalizedApiBasePath}/callback/board-worker`,
-    }),
-  };
+  return createHttpBoardCallbackTransport(`${normalizedServerUrl}${normalizedApiBasePath}/callback/board-worker`);
 }
 
 async function readJsonRequest(req) {
@@ -381,6 +386,437 @@ function createNamedPipeNotificationTransport() {
   };
 }
 
+function createInMemoryNotificationTransport() {
+  const subscribers = new Map();
+
+  return {
+    publish(channel, notifications) {
+      const channelSubscribers = subscribers.get(channel);
+      if (!channelSubscribers?.size) return;
+      const event = notifications.length === 1
+        ? notifications[0]
+        : { kind: 'notification-batch', notifications };
+      for (const onEvent of channelSubscribers) {
+        try { onEvent(event); } catch { /* */ }
+      }
+    },
+
+    async subscribe(ref, onEvent) {
+      if (ref.kind !== 'in-memory-notify') return () => {};
+      const channel = String(ref.value || '');
+      const channelSubscribers = subscribers.get(channel) || new Set();
+      channelSubscribers.add(onEvent);
+      subscribers.set(channel, channelSubscribers);
+      return () => {
+        channelSubscribers.delete(onEvent);
+        if (!channelSubscribers.size) subscribers.delete(channel);
+      };
+    },
+  };
+}
+
+function createNotificationTransport() {
+  const namedPipeTransport = createNamedPipeNotificationTransport();
+  const inMemoryTransport = createInMemoryNotificationTransport();
+
+  return {
+    publish: inMemoryTransport.publish,
+    async subscribe(ref, onEvent) {
+      if (ref.kind === 'in-memory-notify') return inMemoryTransport.subscribe(ref, onEvent);
+      return namedPipeTransport.subscribe(ref, onEvent);
+    },
+  };
+}
+
+class MemoryAsyncKVStorage {
+  constructor() {
+    this.values = new Map();
+  }
+
+  readSync(key) {
+    return this.values.has(key) ? this.values.get(key) : null;
+  }
+
+  writeSync(key, value) {
+    this.values.set(key, value);
+  }
+
+  deleteSync(key) {
+    this.values.delete(key);
+  }
+
+  async read(key) {
+    return this.readSync(key);
+  }
+
+  async write(key, value) {
+    this.writeSync(key, value);
+  }
+
+  async delete(key) {
+    this.deleteSync(key);
+  }
+
+  async listKeys(prefix = '') {
+    return Array.from(this.values.keys()).filter((key) => key.startsWith(prefix)).sort();
+  }
+}
+
+class MemoryAsyncBlobStorage {
+  constructor(kind, keyRefFactory = null) {
+    this.kind = kind;
+    this.keyRefFactory = keyRefFactory;
+    this.textValues = new Map();
+    this.byteValues = new Map();
+  }
+
+  keyRef(key) {
+    if (this.keyRefFactory) return this.keyRefFactory(key);
+    return { kind: this.kind, value: key };
+  }
+
+  async read(key) {
+    if (this.textValues.has(key)) return this.textValues.get(key);
+    const bytes = this.byteValues.get(key);
+    return bytes ? Buffer.from(bytes).toString('utf-8') : null;
+  }
+
+  async write(key, value) {
+    this.textValues.set(key, value);
+    this.byteValues.delete(key);
+  }
+
+  async readBytes(key) {
+    if (this.byteValues.has(key)) return this.byteValues.get(key);
+    if (this.textValues.has(key)) return Buffer.from(this.textValues.get(key), 'utf-8');
+    return null;
+  }
+
+  async writeBytes(key, value) {
+    this.byteValues.set(key, Buffer.from(value));
+    this.textValues.delete(key);
+  }
+
+  async remove(key) {
+    this.textValues.delete(key);
+    this.byteValues.delete(key);
+  }
+
+  async exists(key) {
+    return this.textValues.has(key) || this.byteValues.has(key);
+  }
+
+  async listKeys(prefix = '') {
+    const keys = new Set([
+      ...Array.from(this.textValues.keys()),
+      ...Array.from(this.byteValues.keys()),
+    ]);
+    return Array.from(keys).filter((key) => key.startsWith(prefix)).sort();
+  }
+}
+
+class MemoryAsyncQueueStorage {
+  constructor() {
+    this.queueItems = new Map();
+    this.deadQueueItems = new Map();
+  }
+
+  createId() {
+    return globalThis.crypto?.randomUUID?.() || genShortId();
+  }
+
+  async enqueue(body) {
+    const item = {
+      id: this.createId(),
+      body,
+      enqueuedAt: new Date().toISOString(),
+      attempt: 0,
+    };
+    this.queueItems.set(item.id, item);
+    return item;
+  }
+
+  async enqueueIfAbsent(body, dedupKey) {
+    for (const existing of this.queueItems.values()) {
+      if (existing.dedupKey === dedupKey) return null;
+    }
+    const item = {
+      id: this.createId(),
+      body,
+      enqueuedAt: new Date().toISOString(),
+      attempt: 0,
+      dedupKey,
+    };
+    this.queueItems.set(item.id, item);
+    return { id: item.id, body: item.body, enqueuedAt: item.enqueuedAt, attempt: item.attempt };
+  }
+
+  async lease(opts = {}) {
+    const max = Math.max(1, Math.floor(opts.max ?? 1));
+    const visibilityMs = Math.max(1, Math.floor(opts.visibilityMs ?? 60_000));
+    const now = Date.now();
+    for (const item of this.queueItems.values()) {
+      if (item.leaseExpiresAt && Date.parse(item.leaseExpiresAt) <= now) {
+        delete item.leaseToken;
+        delete item.leaseExpiresAt;
+      }
+    }
+    const leased = [];
+    for (const item of this.queueItems.values()) {
+      if (leased.length >= max) break;
+      if (item.leaseToken) continue;
+      item.attempt += 1;
+      item.leaseToken = this.createId();
+      item.leaseExpiresAt = new Date(Date.now() + visibilityMs).toISOString();
+      leased.push({
+        id: item.id,
+        body: item.body,
+        enqueuedAt: item.enqueuedAt,
+        attempt: item.attempt,
+        leaseToken: item.leaseToken,
+        leaseExpiresAt: item.leaseExpiresAt,
+      });
+    }
+    return leased;
+  }
+
+  async ack(messageId, leaseToken) {
+    const item = this.queueItems.get(messageId);
+    if (!item || item.leaseToken !== leaseToken) return false;
+    this.queueItems.delete(messageId);
+    return true;
+  }
+
+  async nack(messageId, leaseToken, opts = {}) {
+    const item = this.queueItems.get(messageId);
+    if (!item || item.leaseToken !== leaseToken) return false;
+    delete item.leaseToken;
+    delete item.leaseExpiresAt;
+    if (opts.dead) {
+      this.queueItems.delete(messageId);
+      this.deadQueueItems.set(messageId, { ...item, reason: opts.reason });
+    }
+    return true;
+  }
+
+  async peekActive() {
+    return Array.from(this.queueItems.values())
+      .filter((item) => !item.leaseToken)
+      .map((item) => ({ id: item.id, body: item.body, enqueuedAt: item.enqueuedAt, attempt: item.attempt }));
+  }
+
+  async peekDeadLetter() {
+    return Array.from(this.deadQueueItems.values())
+      .map((item) => ({ ...item, body: item.body }));
+  }
+}
+
+function createMemoryAsyncScratchStorage() {
+  const store = new MemoryAsyncBlobStorage('cloud-scratch-key');
+  let seq = 0;
+  return {
+    ...store,
+    async getUniqueKey(prefix = 'scratch', suffix = '.json') {
+      seq += 1;
+      return `${prefix}-${seq}${suffix}`;
+    },
+    async create(value, prefix, suffix) {
+      const key = await this.getUniqueKey(prefix, suffix);
+      await store.write(key, value);
+      return key;
+    },
+    config: {
+      get: () => null,
+      set: () => {},
+    },
+  };
+}
+
+function createMemoryArchiveFactory() {
+  const blobStores = new Map();
+  const journalStreams = new Map();
+  let seq = 0;
+  return {
+    stream(name) {
+      if (!journalStreams.has(name)) journalStreams.set(name, []);
+      const entries = journalStreams.get(name);
+      return {
+        async append(payload) {
+          seq += 1;
+          const entry = { id: `j-${seq}`, payload };
+          entries.push(entry);
+          return entry;
+        },
+        async readAll() {
+          return entries.slice();
+        },
+        async readAfter(cursor) {
+          const idx = cursor ? entries.findIndex((entry) => entry.id === cursor) : -1;
+          const items = idx >= 0 ? entries.slice(idx + 1) : entries.slice();
+          return {
+            entries: items,
+            newCursor: items.length ? items[items.length - 1].id : cursor,
+          };
+        },
+        async clear() {
+          entries.splice(0, entries.length);
+        },
+      };
+    },
+    blob(name) {
+      if (!blobStores.has(name)) blobStores.set(name, new MemoryAsyncBlobStorage('cloud-archive-key'));
+      return blobStores.get(name);
+    },
+    async listStreams(prefix = '') {
+      return Array.from(journalStreams.keys()).filter((key) => key.startsWith(prefix)).sort();
+    },
+    async listBlobs(prefix = '') {
+      return Array.from(blobStores.keys()).filter((key) => key.startsWith(prefix)).sort();
+    },
+    config: {
+      get: () => null,
+      set: () => {},
+    },
+  };
+}
+
+function createImmediateAsyncLock() {
+  let held = false;
+  return {
+    async tryAcquire() {
+      if (held) return null;
+      held = true;
+      return async () => { held = false; };
+    },
+  };
+}
+
+function stableHash(value) {
+  const json = JSON.stringify(value);
+  let hash = 0;
+  for (let i = 0; i < json.length; i += 1) {
+    hash = ((hash << 5) - hash + json.charCodeAt(i)) | 0;
+  }
+  return `h${Math.abs(hash)}`;
+}
+
+function genShortId() {
+  return `${Date.now().toString(16)}${Math.random().toString(16).slice(2, 18)}`;
+}
+
+function normalizeHostedBoardWorkerTransport(runtimeMode, requestedTransport) {
+  if (runtimeMode === 'cloud') return 'http';
+  return requestedTransport;
+}
+
+function seedCloudCardStore(cardStoreKv, cards) {
+  const index = {};
+  const now = new Date().toISOString();
+  for (const card of cards) {
+    if (!card || typeof card !== 'object' || !card.id) continue;
+    const key = String(card.id);
+    cardStoreKv.writeSync(key, card);
+    index[card.id] = {
+      key,
+      checksum: stableHash(card),
+      updatedAt: now,
+    };
+  }
+  cardStoreKv.writeSync('_index', index);
+}
+
+const cloudBoardBundles = new Map();
+
+function getCloudBoardBundle(boardId, notifyChannel, boardDir = null) {
+  if (cloudBoardBundles.has(boardId)) return cloudBoardBundles.get(boardId);
+
+  const kvNamespaces = new Map();
+  const kvRefs = new Map();
+  const blobNamespaces = new Map();
+  const blobKindToNamespace = new Map([
+    ['cloud-blob-key', ''],
+    ['cloud-source-key', 'sources'],
+    ['cloud-archive-key', 'archive'],
+    ['cloud-scratch-key', 'scratch'],
+  ]);
+  const scratchStore = createMemoryAsyncScratchStorage();
+  const archiveFactory = createMemoryArchiveFactory();
+  const journalStorage = archiveFactory.stream('board-journal');
+  const boardWorkerQueueStorage = new MemoryAsyncQueueStorage();
+  const chatAgentQueueStorage = new MemoryAsyncQueueStorage();
+  const processAccumulatedQueueStorage = new MemoryAsyncQueueStorage();
+  const stagedSourcesDir = boardDir ? path.join(path.dirname(boardDir), 'runtime-out', '.cloud-staged-sources') : null;
+  if (stagedSourcesDir) fs.mkdirSync(stagedSourcesDir, { recursive: true });
+
+  const getKvNamespace = (namespace) => {
+    const key = String(namespace || '');
+    if (!kvNamespaces.has(key)) kvNamespaces.set(key, new MemoryAsyncKVStorage());
+    return kvNamespaces.get(key);
+  };
+  const getKvRef = (ref) => {
+    const key = String(ref || '');
+    if (!kvRefs.has(key)) kvRefs.set(key, new MemoryAsyncKVStorage());
+    return kvRefs.get(key);
+  };
+  const getBlobNamespace = (namespace) => {
+    const key = String(namespace || '');
+    if (key === 'scratch') return scratchStore;
+    if (!blobNamespaces.has(key)) {
+      const kind = key === 'sources' ? 'cloud-source-key' : 'cloud-blob-key';
+      const keyRefFactory = key === 'sources' && stagedSourcesDir
+        ? (blobKey) => ({ kind: 'fs-path', value: path.join(stagedSourcesDir, ...String(blobKey).split('/')) })
+        : null;
+      blobNamespaces.set(key, new MemoryAsyncBlobStorage(kind, keyRefFactory));
+    }
+    return blobNamespaces.get(key);
+  };
+
+  const bundle = {
+    getKvNamespace,
+    getKvRef,
+    getBlobNamespace,
+    adapter: null,
+    notifyChannel,
+  };
+
+  bundle.adapter = createHostedAsyncBoardPlatformAdapter({
+    boardId,
+    kvStorage: (namespace) => getKvNamespace(namespace),
+    kvStorageForRef: (ref) => getKvRef(ref),
+    blobStorage: (namespace) => getBlobNamespace(namespace),
+    scratchStorage: () => scratchStore,
+    scratchStorageForRef: () => scratchStore,
+    archiveFactory: () => archiveFactory,
+    archiveFactoryForRef: () => archiveFactory,
+    journalStorage: () => journalStorage,
+    queueStorage: boardWorkerQueueStorage,
+    chatAgentQueueStorage,
+    processAccumulatedQueueStorage,
+    lock: createImmediateAsyncLock(),
+    callbackTransport: undefined,
+    resolveBlob: async (ref) => {
+      if (ref.kind === 'fs-path') {
+        return fs.promises.readFile(ref.value, 'utf-8');
+      }
+      const namespace = blobKindToNamespace.get(ref.kind);
+      if (namespace !== undefined) {
+        const value = await getBlobNamespace(namespace).read(ref.value);
+        if (value != null) return value;
+      }
+      throw new Error(`Blob not found for ref ${ref.kind}:${ref.value}`);
+    },
+    hashFn: stableHash,
+    genId: genShortId,
+    supportsDirectSourceOutput: (ref) => ref?.howToRun === 'http:post',
+    publishBoardChangeNotifications: async (notifications) => {
+      notificationTransport.publish(notifyChannel, notifications);
+    },
+  });
+
+  cloudBoardBundles.set(boardId, bundle);
+  return bundle;
+}
+
 // ---------------------------------------------------------------------------
 // Server meta store (multi-board registry)
 // ---------------------------------------------------------------------------
@@ -397,17 +833,17 @@ const serverMetaStore = createArtifactsStore(serverMetaAdapter.blobStorage('serv
 
 const apiBasePath = '/api/boards';
 const invocationAdapter = createNodeSpawnInvocationAdapter();
-const notificationTransport = createNamedPipeNotificationTransport();
+const notificationTransport = createNotificationTransport();
 const logger = { info: console.log, warn: console.warn, error: console.error };
 const hostedBoardWorkerDispatchers = new Map();
-const hostedBoardWorkerQueueStops = new Map();
+const hostedQueueLaneStops = new Map();
 const hostedBoardChatStorages = new Map();
 
 // Map config keys to board entries for the factory
 const boardConfigEntries = serverConfig.boards ? Object.entries(serverConfig.boards) : [];
 const boardConfigMap = new Map(boardConfigEntries);
 
-function buildBoardContextConfig(label, boardDir, taskExecPath, chatHandlerFlow, infAdapterPath, boardId, executionExtra = {}) {
+function buildBoardContextConfig(label, boardDir, taskExecPath, chatHandlerFlow, infAdapterPath, boardId, executionExtra = {}, runtimeMode = 'sync') {
   fs.mkdirSync(boardDir, { recursive: true });
   const runtimeCardsDir = path.join(path.dirname(boardDir), 'cards');
   const runtimeCardStoreDir = path.join(runtimeCardsDir, 'store');
@@ -419,16 +855,66 @@ function buildBoardContextConfig(label, boardDir, taskExecPath, chatHandlerFlow,
   fs.mkdirSync(archiveDir, { recursive: true });
 
   const notifyChannel = `yaml-flow-server-${label}-${boardId}-${process.pid}`;
+  const boardWorkerTransport = normalizeHostedBoardWorkerTransport(
+    runtimeMode,
+    normalizeBoardWorkerTransport(executionExtra.taskExecutorTransport),
+  );
+  const callbackTransport = makeBoardWorkerCallbackTransport(executionExtra.serverUrl, executionExtra.apiBasePath, boardWorkerTransport, boardId);
+
+  if (runtimeMode === 'cloud') {
+    const cloudBundle = getCloudBoardBundle(boardId, notifyChannel, boardDir);
+    cloudBundle.adapter.callbackTransport = callbackTransport;
+    const cloudNonCoreAdapter = createFsBoardNonCorePlatformAdapter(
+      parseRef(serializeRef({ kind: 'fs-path', value: boardDir })),
+      {
+        notifyChannel,
+        ...(callbackTransport ? { callbackTransport } : {}),
+      },
+    );
+    const cloudHostedTaskExecutorRef = makeHostedBoardWorkerRef(boardId, taskExecPath, boardWorkerTransport, executionExtra);
+    const cloudLocalSyncTaskExecutorRef = makeLocalTaskExecutorRef(taskExecPath, executionExtra);
+    if (cloudLocalSyncTaskExecutorRef) {
+      const invokeExecutor = cloudNonCoreAdapter.invokeExecutor.bind(cloudNonCoreAdapter);
+      cloudNonCoreAdapter.invokeExecutor = (ref, subcommand, execOpts) => {
+        const syncRef = isHostedTaskExecutorRef(ref) ? cloudLocalSyncTaskExecutorRef : ref;
+        return invokeExecutor(syncRef, subcommand, execOpts);
+      };
+    }
+    cloudNonCoreAdapter.requestProcessAccumulated = () => {};
+    try {
+      const seedTeRef = cloudLocalSyncTaskExecutorRef ?? cloudHostedTaskExecutorRef;
+      if (seedTeRef) {
+        cloudNonCoreAdapter.kvStorage('config').write('task-executor', serializeExecutionRef(seedTeRef));
+      }
+    } catch (e) {
+      logger.warn(`[cloud:${boardId}] failed to seed non-core task-executor config: ${e?.message || e}`);
+    }
+    return {
+      label,
+      boardAdapter: cloudBundle.adapter,
+      nonCoreAdapter: cloudNonCoreAdapter,
+      artifactsAdapter: cloudBundle.adapter,
+      baseRef: { kind: 'cloud-board', value: `board:${boardId}` },
+      cardStoreRef: `cloud:${boardId}:cards`,
+      outputsStoreRef: `cloud:${boardId}:runtime-out`,
+      artifactsStoreRef: `cloud:${boardId}:artifacts`,
+      scratchStoreRef: `cloud:${boardId}:scratch`,
+      archiveStoreRef: `cloud:${boardId}:archive`,
+      notifyRef: { kind: 'in-memory-notify', value: notifyChannel },
+      taskExecutorRef: cloudHostedTaskExecutorRef,
+      chatHandlerFlow,
+      inferenceAdapterRef: makeExecutionRef(infAdapterPath),
+    };
+  }
+
   const baseRef = parseRef(serializeRef({ kind: 'fs-path', value: boardDir }));
-  const boardWorkerTransport = normalizeBoardWorkerTransport(executionExtra.taskExecutorTransport);
-  const callbackSelfRef = makeBoardWorkerCallbackSelfRef(executionExtra.serverUrl, executionExtra.apiBasePath, boardWorkerTransport, boardId);
   const boardAdapter = createFsBoardPlatformAdapter(baseRef, {
     notifyChannel,
-    ...(callbackSelfRef ? { selfRef: callbackSelfRef } : {}),
+    ...(callbackTransport ? { callbackTransport } : {}),
   });
   const nonCoreAdapter = createFsBoardNonCorePlatformAdapter(baseRef, {
     notifyChannel,
-    ...(callbackSelfRef ? { selfRef: callbackSelfRef } : {}),
+    ...(callbackTransport ? { callbackTransport } : {}),
   });
   const localSyncTaskExecutorRef = makeLocalTaskExecutorRef(taskExecPath, executionExtra);
   if (localSyncTaskExecutorRef) {
@@ -536,7 +1022,11 @@ const runtime = createMultiBoardServerRuntime({
     );
     const infAdapterPath = resolveFromConfig(regular.inferenceAdapterPath) || (entry?.inferenceAdapterPath || configuredInferenceAdapterPath);
     const stepMachinePath = resolveFromConfig(regular.stepMachineCliPath || cfg?.stepMachineCliPath) || (entry?.stepMachineCliPath || configuredStepMachineCliPath);
-    const boardWorkerTransport = normalizeBoardWorkerTransport(regular.taskExecutorTransport || entry?.taskExecutorTransport || configuredBoardWorkerTransport);
+    const runtimeMode = normalizeRuntimeMode(regular.mode || entry?.mode || cfg?.mode || configuredRuntimeMode);
+    const boardWorkerTransport = normalizeHostedBoardWorkerTransport(
+      runtimeMode,
+      normalizeBoardWorkerTransport(regular.taskExecutorTransport || entry?.taskExecutorTransport || configuredBoardWorkerTransport),
+    );
     const chatInvokeRefTimeoutMs = configuredInvokeRefTimeoutMs;
     const chatCopilotTimeoutMs = configuredCopilotTimeoutMs;
 
@@ -577,11 +1067,20 @@ const runtime = createMultiBoardServerRuntime({
       ...(stepMachinePath ? { stepMachineCliPath: stepMachinePath } : {}),
     };
 
-    const baseCfg = buildBoardContextConfig('base', boardDir, taskExecPath, chatHandlerFlow, infAdapterPath, boardId, baseExecutionExtra);
+    const baseCfg = buildBoardContextConfig('base', boardDir, taskExecPath, chatHandlerFlow, infAdapterPath, boardId, baseExecutionExtra, runtimeMode);
     const boards = [baseCfg];
 
     demoPrepSetup({ cardsDir, boardDir });
 
+    if (runtimeMode === 'cloud' && cardsDir) {
+      const cards = createFsCardSource(cardsDir, selectedCardsPattern).listCards();
+      if (cards.length) {
+        const cloudBundle = getCloudBoardBundle(boardId, baseCfg.notifyRef.value);
+        
+        seedCloudCardStore(cloudBundle.getKvRef(baseCfg.cardStoreRef), cards);
+      }
+    }
+
     const chatStorage = createFsBoardChatStorage(boardDir);
     hostedBoardChatStorages.set(boardId, chatStorage);
 
@@ -612,10 +1111,10 @@ const runtime = createMultiBoardServerRuntime({
     if (hostedBoardWorkerDispatch) {
       hostedBoardWorkerDispatchers.set(boardId, hostedBoardWorkerDispatch);
     }
-    const previousQueueStop = hostedBoardWorkerQueueStops.get(boardId);
+    const previousQueueStop = hostedQueueLaneStops.get(boardId);
     if (previousQueueStop) {
       previousQueueStop();
-      hostedBoardWorkerQueueStops.delete(boardId);
+      hostedQueueLaneStops.delete(boardId);
     }
     if (boardWorkerTransport === 'in-process-loop' && hostedBoardWorkerDispatch) {
       registerInProcessExecutionHandler(`board:${boardId}:board-worker`, async (_ref, args) => {
@@ -625,7 +1124,7 @@ const runtime = createMultiBoardServerRuntime({
         return { result: 'success', data: { dispatched: true } };
       });
     }
-    if ((boardWorkerTransport === 'in-process-loop' || boardWorkerTransport === 'queue') && hostedBoardWorkerDispatch) {
+    if ((boardWorkerTransport === 'in-process-loop' || boardWorkerTransport === 'queue' || boardWorkerTransport === 'http') && hostedBoardWorkerDispatch) {
       registerInProcessBoardWorkerCallback(`board:${boardId}:board-worker-callback`, (payload) => {
         if (payload.outcome === 'success') {
           return singleBoardRuntime.reportSourceFetched(payload.token, String(payload.ref || ''));
@@ -633,25 +1132,25 @@ const runtime = createMultiBoardServerRuntime({
         return singleBoardRuntime.reportSourceFetchFailure(payload.token, String(payload.reason || 'unknown'));
       });
     }
-    if (boardWorkerTransport === 'queue' && hostedBoardWorkerDispatch) {
-      const stopQueueRunner = startBoardWorkerQueueRunner({
-        workerStore: baseCfg.boardAdapter.boardWorkerStore(),
-        executeBoardWorkerRequest: hostedBoardWorkerDispatch,
-        onError: (error, lease) => {
-          logger.error(
-            `[board-server] queued board-worker failed for ${boardId} (attempt ${lease.attempt}): ${String(error && error.message || error)}`,
-          );
-        },
-      });
-      hostedBoardWorkerQueueStops.set(boardId, stopQueueRunner);
-    }
+    const stopQueueRunner = startQueueLaneRunners(createHostedBoardQueueLaneRegistry({
+      boardId,
+      runtime: singleBoardRuntime,
+      boardAdapter: baseCfg.boardAdapter,
+      logger,
+      ...(boardWorkerTransport === 'queue' && hostedBoardWorkerDispatch
+        ? { executeTaskExecutorRequest: hostedBoardWorkerDispatch }
+        : {}),
+    }));
+    hostedQueueLaneStops.set(boardId, stopQueueRunner);
 
     // Seed card store from source cardsDir if empty
-    const existing = singleBoardRuntime.cardStore.get({});
-    const isEmpty = existing.status !== 'success' || !existing.data?.cards?.length;
-    if (isEmpty && cardsDir) {
-      const cards = createFsCardSource(cardsDir, selectedCardsPattern).listCards();
-      if (cards.length) singleBoardRuntime.cardStore.set({ body: cards });
+    if (runtimeMode === 'sync') {
+      const existing = singleBoardRuntime.cardStore.get({});
+      const isEmpty = existing.status !== 'success' || !existing.data?.cards?.length;
+      if (isEmpty && cardsDir) {
+        const cards = createFsCardSource(cardsDir, selectedCardsPattern).listCards();
+        if (cards.length) singleBoardRuntime.cardStore.set({ body: cards });
+      }
     }
 
     return singleBoardRuntime;