@elizaos/app-core 2.0.0-beta.3 → 2.0.3-beta.3

package/scripts/playwright-ui-smoke-api-stub.mjs

@@ -1,10 +1,331 @@
+import { existsSync, readFileSync } from "node:fs";
 import http from "node:http";
+import path from "node:path";
+import { gunzipSync } from "node:zlib";
 import { WebSocketServer } from "ws";
 
 const port = Number(process.env.ELIZA_UI_SMOKE_API_PORT || "31337");
+const repoRoot = path.resolve(new URL("../../..", import.meta.url).pathname);
+const SMOKE_GENERATED_AT = "2026-01-01T00:00:00.000Z";
+const DEMO_ORCHESTRATOR = process.env.ELIZA_UI_SMOKE_DEMO_ORCHESTRATOR === "1";
 let browserWorkspaceCounter = 0;
 let browserWorkspaceTabs = [];
 let lifeOpsAppEnabled = true;
+let conversationCounter = 0;
+let messageCounter = 0;
+const stubConversations = [];
+const stubConversationMessages = new Map();
+const unhandledApiRequests = [];
+const ONE_PIXEL_PNG = Buffer.from(
+  "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+/p9sAAAAASUVORK5CYII=",
+  "base64",
+);
+
+// A minimal valid 16-bit PCM mono WAV of silence. The onboarding voice path
+// POSTs /api/tts/first-run/speak and plays the returned bytes as audio/wav, so
+// the stub must return decodable audio (not a 501) to avoid a console.error.
+function buildSilentWav() {
+  const sampleRate = 8000;
+  const dataBytes = 1600; // ~0.1s of silence
+  const header = Buffer.alloc(44);
+  header.write("RIFF", 0, "ascii");
+  header.writeUInt32LE(36 + dataBytes, 4);
+  header.write("WAVE", 8, "ascii");
+  header.write("fmt ", 12, "ascii");
+  header.writeUInt32LE(16, 16); // PCM fmt chunk size
+  header.writeUInt16LE(1, 20); // audioFormat = PCM
+  header.writeUInt16LE(1, 22); // mono
+  header.writeUInt32LE(sampleRate, 24);
+  header.writeUInt32LE(sampleRate * 2, 28); // byteRate (mono, 16-bit)
+  header.writeUInt16LE(2, 32); // blockAlign
+  header.writeUInt16LE(16, 34); // bitsPerSample
+  header.write("data", 36, "ascii");
+  header.writeUInt32LE(dataBytes, 40);
+  return Buffer.concat([header, Buffer.alloc(dataBytes)]);
+}
+
+const SILENT_WAV = buildSilentWav();
+// Deterministic transcript the local-inference ASR stub returns for any audio
+// the /chat overlay captures — keeps the voice e2e turn reproducible.
+const SMOKE_VOICE_TRANSCRIPT = "this is the voice smoke transcript";
+// The spoken reply the stub returns for that transcript — a clean sentence so
+// the overlay's TTS output is non-empty and the assistant bubble is assertable.
+const SMOKE_VOICE_REPLY = "Got it, this is the spoken reply.";
+function readSmokeVrm() {
+  const candidates = [
+    new URL(
+      "../../../plugins/plugin-companion/public/vrms/eliza-1.vrm.gz",
+      import.meta.url,
+    ),
+    new URL(
+      "../../../plugins/plugin-companion/public_src/vrms/eliza-1.vrm",
+      import.meta.url,
+    ),
+  ];
+
+  for (const candidate of candidates) {
+    if (!existsSync(candidate)) continue;
+    const body = readFileSync(candidate);
+    return candidate.pathname.endsWith(".gz") ? gunzipSync(body) : body;
+  }
+
+  return Buffer.alloc(4);
+}
+
+const SMOKE_VRM = readSmokeVrm();
+
+// A collapsed plugin declares ONE view that draws gui + tui (+ xr) from the
+// same `<Name>View` componentExport and the same bundle on the same `/<id>`
+// route. In the stub a `modalities` 6th element expands that single declaration
+// into one gui object + one tui object (both at `/<id>`, both serving the same
+// componentExport), mirroring how the real /api/views collapses modalities.
+// Plugins that still declare a standalone tui route (training) keep a separate
+// `tui` row with its own `/<id>/tui` path below.
+const smokeViewDeclarations = [
+  [
+    "companion",
+    "Companion",
+    "plugin-companion",
+    "/companion",
+    "CompanionView",
+    ["gui", "tui"],
+  ],
+  [
+    "contacts",
+    "Contacts",
+    "plugin-contacts",
+    "/contacts",
+    "ContactsView",
+    ["gui", "tui"],
+  ],
+  [
+    "hyperliquid",
+    "Hyperliquid",
+    "plugin-hyperliquid-app",
+    "/hyperliquid",
+    "HyperliquidView",
+    ["gui", "tui"],
+  ],
+  // NOTE: the LifeOps overview view was removed (PA no longer registers a
+  // `lifeops` view). Its stub entries are deleted so the smoke launcher matches
+  // production. The decomposed per-domain views below are the real surfaces.
+  // Decomposed personal-assistant domain views — registered so their dynamic
+  // bundles load in keyless ui-smoke and the decomposed-interactions spec can
+  // drive them (closing INTERACTION_DEBT in view-interaction-coverage.test.ts).
+  // NOTE: "documents" is intentionally NOT registered here — its view path
+  // `/documents` collides with the built-in "documents" tab (App.tsx findView
+  // matches `/${tab}`), which would hijack the `/character/documents` route.
+  ["calendar", "Calendar", "plugin-calendar", "/calendar", "CalendarView"],
+  ["finances", "Finances", "plugin-finances", "/finances", "FinancesView"],
+  ["focus", "Focus", "plugin-blocker", "/focus", "FocusView"],
+  ["goals", "Goals", "plugin-goals", "/goals", "GoalsView"],
+  ["health", "Health", "plugin-health", "/health", "HealthView"],
+  ["inbox", "Inbox", "plugin-inbox", "/inbox", "InboxView"],
+  ["todos", "Todos", "plugin-todos", "/todos", "TodosView"],
+  [
+    "relationships",
+    "Relationships",
+    "plugin-relationships",
+    "/relationships",
+    "RelationshipsView",
+  ],
+  [
+    "messages",
+    "Messages",
+    "plugin-messages",
+    "/messages",
+    "MessagesView",
+    ["gui", "tui"],
+  ],
+  [
+    "model-tester",
+    "Model Tester",
+    "app-model-tester",
+    "/model-tester",
+    "ModelTesterView",
+    ["gui", "tui"],
+  ],
+  // Phone collapsed to ONE source: gui + tui (+ xr) all mount the single
+  // PhoneView spatial component from the same bundle.
+  ["phone", "Phone", "plugin-phone", "/phone", "PhoneView", ["gui", "tui"]],
+  [
+    "polymarket",
+    "Polymarket",
+    "plugin-polymarket-app",
+    "/polymarket",
+    "PolymarketView",
+    ["gui", "tui"],
+  ],
+  [
+    "shopify",
+    "Shopify",
+    "plugin-shopify-ui",
+    "/shopify",
+    "ShopifyView",
+    ["gui", "tui"],
+  ],
+  [
+    "steward",
+    "Steward",
+    "plugin-steward-app",
+    "/steward",
+    "StewardView",
+    ["gui", "tui"],
+  ],
+  [
+    "vincent",
+    "Vincent",
+    "plugin-vincent",
+    "/vincent",
+    "VincentView",
+    ["gui", "tui"],
+  ],
+  [
+    "wallet",
+    "Wallet",
+    "plugin-wallet-ui",
+    "/wallet",
+    "InventoryView",
+    ["gui", "tui"],
+  ],
+  [
+    "vector-browser",
+    "Vector Browser",
+    "plugin-vector-browser",
+    "/vector-browser",
+    "VectorBrowserView",
+  ],
+  ["feed", "Feed", "plugin-feed", "/feed", "FeedView", ["gui", "tui"]],
+  [
+    "views-manager",
+    "Views",
+    "plugin-app-control",
+    "/views",
+    "ViewManagerView",
+    ["gui", "tui"],
+  ],
+  [
+    "screenshare",
+    "Screenshare",
+    "plugin-screenshare",
+    "/screenshare",
+    "ScreenshareView",
+    ["gui", "tui"],
+  ],
+  [
+    "social-alpha",
+    "Social Alpha",
+    "plugin-social-alpha",
+    "/social-alpha",
+    "SocialAlphaView",
+  ],
+  [
+    "task-coordinator",
+    "Task Coordinator",
+    "plugin-task-coordinator",
+    "/task-coordinator",
+    "TaskCoordinatorView",
+    ["gui", "tui"],
+  ],
+  [
+    "orchestrator",
+    "Orchestrator",
+    "plugin-task-coordinator",
+    "/orchestrator",
+    "OrchestratorView",
+    ["gui", "tui"],
+  ],
+  [
+    "trajectory-logger",
+    "Trajectory Logger",
+    "plugin-trajectory-logger",
+    "/trajectory-logger",
+    "TrajectoryLoggerView",
+    ["gui", "tui"],
+  ],
+  // Training is NOT collapsed: it keeps a standalone gui route plus a separate
+  // tui declaration on its own `/training/tui` route.
+  ["training", "Fine Tuning", "plugin-training", "/training", "FineTuningView"],
+  [
+    "training",
+    "Fine Tuning TUI",
+    "plugin-training",
+    "/training/tui",
+    "FineTuningTuiView",
+    "tui",
+  ],
+];
+
+function smokeViewObject({
+  id,
+  label,
+  pluginDirName,
+  viewPath,
+  componentExport,
+  viewType,
+}) {
+  const encodedId = encodeURIComponent(id);
+  const query = viewType === "tui" ? "?viewType=tui&v=ui-smoke" : "?v=ui-smoke";
+  const bundlePath = path.join(
+    repoRoot,
+    "plugins",
+    pluginDirName,
+    "dist",
+    "views",
+    "bundle.js",
+  );
+  return {
+    id,
+    label,
+    viewType,
+    pluginName: `@elizaos/${pluginDirName}`,
+    path: viewPath,
+    order: 100,
+    bundlePath: "dist/views/bundle.js",
+    bundleUrl: `/api/views/${encodedId}/bundle.js${query}`,
+    componentExport,
+    available: true,
+    realBundleAvailable: existsSync(bundlePath),
+    visibleInManager: true,
+    capabilities: [
+      {
+        id: "get-state",
+        label: "Get state",
+        inputSchema: { type: "object" },
+      },
+    ],
+    _smokePluginDirName: pluginDirName,
+  };
+}
+
+// A collapsed declaration carries a `modalities` array as its 6th element and
+// expands to one view object per surface (gui + tui), all sharing the same
+// `/<id>` route and `<Name>View` componentExport. A legacy declaration carries
+// a single `viewType` string (default "gui").
+const smokeViews = smokeViewDeclarations.flatMap(
+  ([
+    id,
+    label,
+    pluginDirName,
+    viewPath,
+    componentExport,
+    modalitiesOrViewType = "gui",
+  ]) => {
+    const viewTypes = Array.isArray(modalitiesOrViewType)
+      ? modalitiesOrViewType
+      : [modalitiesOrViewType];
+    return viewTypes.map((viewType) =>
+      smokeViewObject({
+        id,
+        label,
+        pluginDirName,
+        viewPath,
+        componentExport,
+        viewType,
+      }),
+    );
+  },
+);
 
 const stubPlugins = [
   {
@@ -89,12 +410,14 @@ function stubCatalogApp({
 
 const stubCatalogApps = [
   stubCatalogApp({
-    name: "@elizaos/app-lifeops",
+    name: "@elizaos/plugin-personal-assistant",
     displayName: "LifeOps",
     description:
       "Run tasks, reminders, calendar, inbox, and connected workflows.",
     capabilities: ["lifeops", "tasks", "calendar", "gmail"],
-    heroImage: "/app-heroes/lifeops.png",
+    // No heroImage: the lifeops surface was removed and /app-heroes/lifeops.png
+    // does not exist; the catalog renders the hero conditionally, so omitting it
+    // avoids the 404 console error (which the visual smoke asserts against).
   }),
   stubCatalogApp({
     name: "@elizaos/app-plugin-viewer",
@@ -112,7 +435,7 @@ const stubCatalogApps = [
     heroImage: "/app-heroes/skills-viewer.png",
   }),
   stubCatalogApp({
-    name: "@elizaos/app-training",
+    name: "@elizaos/plugin-training",
     displayName: "Fine Tuning",
     description:
       "Build datasets, inspect trajectories, and activate tuned models.",
@@ -162,25 +485,53 @@ const stubCatalogApps = [
     heroImage: "/app-heroes/log-viewer.png",
   }),
   stubCatalogApp({
-    name: "@elizaos/app-companion",
+    name: "@elizaos/plugin-companion",
     displayName: "Companion",
     description: "The companion overlay shell for ambient agent presence.",
     category: "social",
   }),
   stubCatalogApp({
-    name: "@elizaos/app-shopify",
+    name: "@elizaos/plugin-steward-app",
+    displayName: "Steward",
+    description: "Review wallet approvals and inventory status.",
+    capabilities: ["wallet", "approvals", "inventory"],
+  }),
+  stubCatalogApp({
+    name: "@elizaos/plugin-elizamaker",
+    displayName: "ElizaMaker",
+    description: "Run drop, mint, whitelist, and verification workflows.",
+    capabilities: ["drops", "minting", "whitelist"],
+  }),
+  stubCatalogApp({
+    name: "@elizaos/plugin-shopify-ui",
     displayName: "Shopify",
     description: "Manage Shopify store operations from the agent workspace.",
     category: "platform",
   }),
   stubCatalogApp({
-    name: "@elizaos/app-vincent",
+    name: "@elizaos/plugin-vincent",
     displayName: "Vincent",
     description: "Manage Vincent DeFi account access and trading context.",
     category: "platform",
   }),
+  stubCatalogApp({
+    name: "@elizaos/plugin-hyperliquid-app",
+    displayName: "Hyperliquid",
+    description: "Inspect Hyperliquid markets, positions, and order status.",
+    category: "platform",
+    capabilities: ["hyperliquid", "trading", "wallet"],
+  }),
+  stubCatalogApp({
+    name: "@elizaos/plugin-polymarket-app",
+    displayName: "Polymarket",
+    description: "Browse prediction markets and native trading readiness.",
+    category: "platform",
+    capabilities: ["polymarket", "prediction-markets", "wallet"],
+  }),
 ];
 
+let smokeFavoriteApps = [];
+
 const stubMemoryStats = {
   total: 0,
   byType: {},
@@ -390,6 +741,113 @@ const emptyWalletMarketOverview = {
   predictions: [],
 };
 
+const stubHyperliquidStatus = {
+  publicReadReady: true,
+  signerReady: false,
+  executionReady: false,
+  executionBlockedReason:
+    "Signed Hyperliquid exchange mutations are disabled in UI smoke.",
+  accountAddress: null,
+  apiBaseUrl: "https://api.hyperliquid.xyz",
+  credentialMode: "none",
+  readiness: {
+    publicReads: true,
+    accountReads: false,
+    signer: false,
+    execution: false,
+  },
+  account: {
+    address: null,
+    source: "none",
+    guidance:
+      "Connect a managed vault or configure an account address for account reads.",
+  },
+  vault: {
+    configured: false,
+    ready: false,
+    address: null,
+    guidance: "Public market reads do not require a vault.",
+  },
+  apiWallet: {
+    configured: false,
+    guidance: "API-wallet delegation is optional.",
+  },
+};
+
+const stubHyperliquidMarkets = {
+  markets: [
+    {
+      name: "BTC",
+      index: 0,
+      szDecimals: 5,
+      maxLeverage: 50,
+      onlyIsolated: false,
+      isDelisted: false,
+    },
+    {
+      name: "ETH",
+      index: 1,
+      szDecimals: 4,
+      maxLeverage: 50,
+      onlyIsolated: false,
+      isDelisted: false,
+    },
+  ],
+  source: "hyperliquid-info-meta",
+  fetchedAt: "2026-01-01T00:00:00.000Z",
+};
+
+const stubPolymarketStatus = {
+  publicReads: {
+    ready: true,
+    reason: null,
+    gammaApiBase: "https://gamma-api.polymarket.com",
+    dataApiBase: "https://data-api.polymarket.com",
+  },
+  trading: {
+    ready: false,
+    credentialsReady: false,
+    missing: [
+      "POLYMARKET_PRIVATE_KEY",
+      "CLOB_API_KEY",
+      "CLOB_API_SECRET",
+      "CLOB_API_PASSPHRASE",
+    ],
+    reason: "Trading is disabled in UI smoke.",
+    clobApiBase: "https://clob.polymarket.com",
+  },
+};
+
+const stubPolymarketMarket = {
+  id: "ui-smoke-market",
+  slug: "ui-smoke-market",
+  question: "Will the UI smoke suite stay green?",
+  description: "Deterministic fixture market for app-window QA.",
+  category: "QA",
+  active: true,
+  closed: false,
+  archived: false,
+  restricted: false,
+  enableOrderBook: true,
+  conditionId: "0xsmoke",
+  clobTokenIds: ["yes-token", "no-token"],
+  outcomes: [
+    { name: "Yes", price: "0.72" },
+    { name: "No", price: "0.28" },
+  ],
+  liquidity: "10000",
+  volume: "42000",
+  volume24hr: "1200",
+  lastTradePrice: "0.72",
+  bestBid: "0.71",
+  bestAsk: "0.73",
+  image: null,
+  icon: null,
+  endDate: null,
+  startDate: "2026-01-01T00:00:00.000Z",
+  updatedAt: "2026-01-01T00:00:00.000Z",
+};
+
 const smokeGeneratedAt = "2026-01-01T00:00:00.000Z";
 
 const emptyLifeOpsOverviewSummary = {
@@ -662,6 +1120,144 @@ function parsePositiveInt(value, fallback) {
   return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
 }
 
+function createStubConversation({ title = "New chat", metadata = {} } = {}) {
+  conversationCounter += 1;
+  const createdAt = nowIso();
+  const conversation = {
+    id: `stub-conversation-${conversationCounter}`,
+    title:
+      typeof title === "string" && title.trim().length > 0
+        ? title.trim()
+        : "New chat",
+    roomId: `stub-room-${conversationCounter}`,
+    metadata:
+      metadata && typeof metadata === "object" && !Array.isArray(metadata)
+        ? metadata
+        : {},
+    createdAt,
+    updatedAt: createdAt,
+  };
+  stubConversations.unshift(conversation);
+  stubConversationMessages.set(conversation.id, []);
+  return conversation;
+}
+
+function findStubConversation(id) {
+  return stubConversations.find((conversation) => conversation.id === id);
+}
+
+function createStubMessage(role, text) {
+  messageCounter += 1;
+  return {
+    id: `stub-message-${messageCounter}`,
+    role,
+    text: typeof text === "string" ? text : "",
+    timestamp: Date.now(),
+  };
+}
+
+function stableTextHash(text) {
+  let hash = 0x811c9dc5;
+  for (let index = 0; index < text.length; index += 1) {
+    hash ^= text.charCodeAt(index);
+    hash = Math.imul(hash, 0x01000193) >>> 0;
+  }
+  return hash.toString(16).padStart(8, "0");
+}
+
+function normalizeAssistantInput(value) {
+  return typeof value === "string" ? value.trim().replace(/\s+/g, " ") : "";
+}
+
+function classifyAssistantAction(text) {
+  const normalized = text.toLowerCase();
+  if (/\b(wallet|inventory|address|balance)\b/.test(normalized)) {
+    return { type: "navigate", target: "/wallet" };
+  }
+  if (/\b(view|views|app|apps)\b/.test(normalized)) {
+    return { type: "navigate", target: "/views" };
+  }
+  if (/\b(setting|settings|provider|model|voice)\b/.test(normalized)) {
+    return { type: "navigate", target: "/settings" };
+  }
+  if (/\b(chat|conversation|message)\b/.test(normalized)) {
+    return { type: "navigate", target: "/chat" };
+  }
+  return { type: "noop", target: null };
+}
+
+function createDeterministicAssistantText({ body, conversationId, transport }) {
+  const inputText = normalizeAssistantInput(body?.text ?? body?.message);
+  if (inputText === SMOKE_VOICE_TRANSCRIPT) {
+    // Voice e2e: reply to the spoken turn with a plain sentence (not the JSON
+    // fixture) so the bidirectional voice output is speakable + assertable.
+    return SMOKE_VOICE_REPLY;
+  }
+  if (/\bbroken[_ -]?llm[_ -]?response\b/i.test(inputText)) {
+    return `BROKEN_MOCK_LLM_RESPONSE:${JSON.stringify({
+      fixture: "ui-smoke-assistant-v1",
+      conversationId,
+      transport,
+      input: { text: inputText },
+      action: classifyAssistantAction(inputText),
+    }).slice(0, -2)}`;
+  }
+  const payload = {
+    fixture: "ui-smoke-assistant-v1",
+    registrySeam: "strict-fixture-registry",
+    conversationId,
+    transport,
+    input: {
+      text: inputText,
+      length: inputText.length,
+      hash: stableTextHash(inputText),
+    },
+    action: classifyAssistantAction(inputText),
+  };
+  return JSON.stringify(payload);
+}
+
+function recordUnhandledApiRequest(req, url) {
+  const entry = {
+    method: req.method ?? "GET",
+    path: url.pathname,
+    search: url.search,
+    at: nowIso(),
+  };
+  unhandledApiRequests.push(entry);
+  if (unhandledApiRequests.length > 50) {
+    unhandledApiRequests.shift();
+  }
+  console.error(
+    `[playwright-ui-smoke-api-stub] unhandled API route: ${entry.method} ${entry.path}${entry.search}`,
+  );
+  return entry;
+}
+
+function appendStubMessage(conversationId, message) {
+  const messages = stubConversationMessages.get(conversationId) ?? [];
+  messages.push(message);
+  stubConversationMessages.set(conversationId, messages);
+  const conversation = findStubConversation(conversationId);
+  if (conversation) conversation.updatedAt = nowIso();
+  return message;
+}
+
+function cleanupEmptyStubConversations({ keepId } = {}) {
+  const deleted = [];
+  for (let index = stubConversations.length - 1; index >= 0; index -= 1) {
+    const conversation = stubConversations[index];
+    if (typeof keepId === "string" && conversation.id === keepId) continue;
+    const messages = stubConversationMessages.get(conversation.id) ?? [];
+    const hasUserMessage = messages.some((message) => message.role === "user");
+    if (hasUserMessage) continue;
+    stubConversations.splice(index, 1);
+    stubConversationMessages.delete(conversation.id);
+    deleted.push(conversation.id);
+  }
+  return deleted;
+}
+
 function buildRuntimeSnapshot(url) {
   const maxDepth = parsePositiveInt(url.searchParams.get("depth"), 10);
   const maxArrayLength = parsePositiveInt(
@@ -878,6 +1474,581 @@ function sendEmpty(req, res, status) {
   res.end();
 }
 
+function sendBinary(req, res, status, contentType, body) {
+  applyCors(req, res);
+  res.statusCode = status;
+  res.setHeader("Content-Type", contentType);
+  res.end(req.method === "HEAD" ? undefined : body);
+}
+
+function contentTypeForSmokeViewAsset(assetPath) {
+  const ext = path.extname(assetPath).toLowerCase();
+  if (ext === ".js" || ext === ".mjs")
+    return "application/javascript; charset=utf-8";
+  if (ext === ".css") return "text/css; charset=utf-8";
+  if (ext === ".map" || ext === ".json")
+    return "application/json; charset=utf-8";
+  if (ext === ".svg") return "image/svg+xml";
+  if (ext === ".png") return "image/png";
+  if (ext === ".jpg" || ext === ".jpeg") return "image/jpeg";
+  if (ext === ".webp") return "image/webp";
+  return "application/octet-stream";
+}
+
+function convertNamedImportsToDestructuring(namedImports) {
+  return namedImports
+    .split(",")
+    .map((part) => part.trim())
+    .filter(Boolean)
+    .map((part) => part.replace(/\s+as\s+/u, ": "))
+    .join(", ");
+}
+
+function buildHostExternalImportReplacement(importClause, specifier, index) {
+  const moduleVar = `__eliza_dynamic_view_host_external_${index}`;
+  const lines = [
+    `const ${moduleVar} = await globalThis.__ELIZA_DYNAMIC_VIEW_IMPORT__(${JSON.stringify(specifier)});`,
+  ];
+  const trimmed = importClause.trim();
+  if (trimmed.startsWith("* as ")) {
+    lines.push(`const ${trimmed.slice("* as ".length).trim()} = ${moduleVar};`);
+    return lines.join("\n");
+  }
+  const namedMatch = trimmed.match(/^\{([\s\S]*)\}$/u);
+  if (namedMatch) {
+    lines.push(
+      `const { ${convertNamedImportsToDestructuring(namedMatch[1])} } = ${moduleVar};`,
+    );
+    return lines.join("\n");
+  }
+  const defaultAndNamedMatch = trimmed.match(/^([^,]+),\s*\{([\s\S]*)\}$/u);
+  if (defaultAndNamedMatch) {
+    lines.push(
+      `const ${defaultAndNamedMatch[1].trim()} = ${moduleVar}.default ?? ${moduleVar};`,
+    );
+    lines.push(
+      `const { ${convertNamedImportsToDestructuring(defaultAndNamedMatch[2])} } = ${moduleVar};`,
+    );
+    return lines.join("\n");
+  }
+  lines.push(`const ${trimmed} = ${moduleVar}.default ?? ${moduleVar};`);
+  return lines.join("\n");
+}
+
+function rewriteHostExternalImports(source, specifiers) {
+  if (specifiers.length === 0) return source;
+  const specifierPattern = specifiers
+    .map((item) => item.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&"))
+    .join("|");
+  const fromImportPattern = new RegExp(
+    `import\\s+([^;]*?)\\s+from\\s+["'](${specifierPattern})["'];?`,
+    "gu",
+  );
+  const sideEffectPattern = new RegExp(
+    `import\\s+["'](${specifierPattern})["'];?`,
+    "gu",
+  );
+  let replacementIndex = 0;
+  return source
+    .replace(fromImportPattern, (_match, importClause, specifier) =>
+      buildHostExternalImportReplacement(
+        String(importClause),
+        String(specifier),
+        replacementIndex++,
+      ),
+    )
+    .replace(
+      sideEffectPattern,
+      (_match, specifier) =>
+        `await globalThis.__ELIZA_DYNAMIC_VIEW_IMPORT__(${JSON.stringify(String(specifier))});`,
+    );
+}
+
+function parseHostExternalSpecifiers(url) {
+  if (url.searchParams.get("hostExternalRuntime") !== "1") return [];
+  return (url.searchParams.get("hostExternalSpecifiers") ?? "")
+    .split(",")
+    .map((item) => item.trim())
+    .filter(Boolean);
+}
+
+function smokeViewByRequest(id, viewType) {
+  return smokeViews.find(
+    (view) => view.id === id && view.viewType === (viewType || "gui"),
+  );
+}
+
+function safeComponentExportName(value) {
+  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(value) ? value : "SmokeView";
+}
+
+function smokeTuiViewBundleSource(view, exportName) {
+  const label = JSON.stringify(view.label);
+  const id = JSON.stringify(view.id);
+  const viewType = JSON.stringify(view.viewType);
+  const pluginName = JSON.stringify(view.pluginName);
+  const commands =
+    view.id === "feed"
+      ? [
+          "refresh-agent-status",
+          "refresh-feed",
+          "list-agents",
+          "summarize-feed",
+        ]
+      : ["status", "refresh", "inspect", "help"];
+  return `import React from "react";
+
+const viewMeta = {
+  id: ${id},
+  label: ${label},
+  viewType: ${viewType},
+  pluginName: ${pluginName}
+};
+const commands = ${JSON.stringify(commands)};
+
+function SmokeView() {
+  const [outputs, setOutputs] = React.useState([]);
+  const runCommand = async (command) => {
+    window.dispatchEvent(new CustomEvent("eliza:tui-command", {
+      detail: { viewId: viewMeta.id, command }
+    }));
+    let result;
+    try {
+      const response = await fetch("/api/views/" + encodeURIComponent(viewMeta.id) + "/interact?viewType=tui", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ capability: command, timeoutMs: 5000 })
+      });
+      result = await response.json();
+    } catch (error) {
+      result = { ok: false, error: error instanceof Error ? error.message : String(error) };
+    }
+    setOutputs((current) => [...current, { command, result }]);
+  };
+  const state = JSON.stringify({
+    viewId: viewMeta.id,
+    viewType: "tui",
+    status: "ready",
+    fixture: "ui-smoke",
+    commandCount: commands.length
+  });
+  return React.createElement(
+    "div",
+    {
+      "data-view-state": state,
+      style: {
+        minHeight: "100vh",
+        background: "#020617",
+        color: "#cbd5e1",
+        fontFamily: "ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace",
+        padding: 20
+      }
+    },
+    React.createElement("div", { style: { color: "#7dd3fc", marginBottom: 4 } }, "elizaos://" + viewMeta.id + " --type=tui"),
+    React.createElement("div", { style: { color: "#94a3b8", marginBottom: 16 } }, viewMeta.label + " smoke terminal"),
+    React.createElement(
+      "div",
+      { style: { display: "flex", flexWrap: "wrap", gap: 8 } },
+      ...commands.map((command) =>
+        React.createElement(
+          "button",
+          {
+            key: command,
+            type: "button",
+            "data-terminal-command": command,
+            onClick: () => void runCommand(command),
+            style: {
+              border: "1px solid #38bdf8",
+              borderRadius: 4,
+              color: "#e0f2fe",
+              background: "transparent",
+              padding: "6px 10px"
+            }
+          },
+          command
+        )
+      )
+    ),
+    ...outputs.map((entry, index) =>
+      React.createElement(
+        "pre",
+        {
+          key: entry.command + index,
+          "data-terminal-output": entry.result?.ok ? "ok" : "error",
+          style: {
+            marginTop: 8,
+            whiteSpace: "pre-wrap",
+            color: entry.result?.ok ? "#bbf7d0" : "#fecaca"
+          }
+        },
+        "$ " + entry.command + "\\n" + JSON.stringify(entry.result, null, 2)
+      )
+    )
+  );
+}
+
+export { SmokeView as ${exportName} };
+export default SmokeView;
+export async function interact(capability, params = {}) {
+  return { ok: true, viewId: viewMeta.id, viewType: viewMeta.viewType, capability, params };
+}
+`;
+}
+
+function smokeScreenshareBundleSource(view, exportName) {
+  const label = JSON.stringify(view.label);
+  const id = JSON.stringify(view.id);
+  const viewType = JSON.stringify(view.viewType);
+  const pluginName = JSON.stringify(view.pluginName);
+  return `import React from "react";
+
+const viewMeta = {
+  id: ${id},
+  label: ${label},
+  viewType: ${viewType},
+  pluginName: ${pluginName}
+};
+
+function maskSession(value) {
+  if (!value) return "";
+  return value.slice(0, 6) + "\\u2026" + value.slice(-4);
+}
+
+function maskToken(value) {
+  if (!value) return "";
+  return "\\u2022\\u2022\\u2022\\u2022 " + value.slice(-4);
+}
+
+function SmokeView() {
+  const [capabilities, setCapabilities] = React.useState(null);
+  const [host, setHost] = React.useState(null);
+  const [token, setToken] = React.useState("");
+  const [viewerUrl, setViewerUrl] = React.useState("");
+  const [remoteBase, setRemoteBase] = React.useState("");
+  const [remoteSession, setRemoteSession] = React.useState("");
+  const [remoteToken, setRemoteToken] = React.useState("");
+
+  const refreshCapabilities = React.useCallback(async () => {
+    const response = await fetch("/api/apps/screenshare/capabilities");
+    setCapabilities(await response.json());
+  }, []);
+
+  React.useEffect(() => {
+    void refreshCapabilities();
+  }, [refreshCapabilities]);
+
+  const startHost = async () => {
+    const response = await fetch("/api/apps/screenshare/session", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ label: "This machine" })
+    });
+    const result = await response.json();
+    setHost(result.session);
+    setToken(result.token);
+    setViewerUrl(result.viewerUrl);
+  };
+
+  const copyDetails = async () => {
+    await navigator.clipboard.writeText(JSON.stringify({
+      sessionId: host?.id,
+      token
+    }));
+  };
+
+  const openHostViewer = () => {
+    if (viewerUrl) window.open(viewerUrl);
+  };
+
+  const openRemote = () => {
+    const url = new URL("/api/apps/screenshare/viewer", remoteBase);
+    url.searchParams.set("sessionId", remoteSession);
+    url.searchParams.set("token", remoteToken);
+    url.searchParams.set("remoteBase", remoteBase);
+    window.open(url.toString());
+  };
+
+  const stopHost = async () => {
+    if (!host?.id) return;
+    const response = await fetch("/api/apps/screenshare/session/" + encodeURIComponent(host.id) + "/stop", {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        "x-screenshare-token": token
+      },
+      body: JSON.stringify({ token })
+    });
+    const result = await response.json();
+    setHost(result.session);
+  };
+
+  const capabilityList = capabilities?.capabilities ?? {};
+  return React.createElement(
+    "section",
+    { "aria-label": viewMeta.label, style: { minHeight: "100vh", padding: 24 } },
+    React.createElement("h1", null, viewMeta.label),
+    React.createElement("p", null, viewMeta.pluginName + " dynamic view smoke surface is ready."),
+    React.createElement("h2", null, "Host"),
+    React.createElement("button", { type: "button", onClick: startHost }, "Start host session"),
+    host && React.createElement("button", { type: "button", onClick: copyDetails }, "Copy host details"),
+    host && React.createElement("button", { type: "button", onClick: openHostViewer }, "Open host viewer"),
+    host && React.createElement("button", { type: "button", onClick: stopHost }, "Stop host session"),
+    host && React.createElement("div", null,
+      React.createElement("input", { placeholder: "Session", readOnly: true, value: maskSession(host.id) }),
+      React.createElement("input", { placeholder: "Token", readOnly: true, value: maskToken(token) }),
+      React.createElement("span", null, String(host.frameCount ?? 0)),
+      React.createElement("span", null, String(host.inputCount ?? 0)),
+      React.createElement("span", null, host.status)
+    ),
+    React.createElement("h2", null, "Capabilities"),
+    React.createElement("button", { type: "button", onClick: () => void refreshCapabilities() }, "Refresh capabilities"),
+    React.createElement("div", null,
+      React.createElement("span", null, "Screenshot"),
+      React.createElement("span", null, capabilityList.screenshot?.available ? "Ready" : "Unavailable")
+    ),
+    React.createElement("div", null,
+      React.createElement("span", null, "Keyboard"),
+      React.createElement("span", null, capabilityList.keyboard?.available ? "Ready" : "Unavailable")
+    ),
+    React.createElement("h2", null, "Remote"),
+    React.createElement("input", { placeholder: "Server URL", value: remoteBase, onChange: (event) => setRemoteBase(event.target.value) }),
+    React.createElement("input", { placeholder: "Session", value: remoteSession, onChange: (event) => setRemoteSession(event.target.value) }),
+    React.createElement("input", { placeholder: "Token", value: remoteToken, onChange: (event) => setRemoteToken(event.target.value) }),
+    React.createElement("button", { type: "button", onClick: openRemote }, "Connect to remote")
+  );
+}
+
+export { SmokeView as ${exportName} };
+export default SmokeView;
+export async function interact(capability, params = {}) {
+  return { ok: true, viewId: viewMeta.id, viewType: viewMeta.viewType, capability, params };
+}
+`;
+}
+
+function smokeTaskCoordinatorBundleSource(view, exportName) {
+  const label = JSON.stringify(view.label);
+  const id = JSON.stringify(view.id);
+  const viewType = JSON.stringify(view.viewType);
+  const pluginName = JSON.stringify(view.pluginName);
+  return `import React from "react";
+
+const viewMeta = {
+  id: ${id},
+  label: ${label},
+  viewType: ${viewType},
+  pluginName: ${pluginName}
+};
+
+function statusLabel(thread) {
+  return String(thread?.status ?? "open").replace(/_/g, " ");
+}
+
+function SmokeView() {
+  const [tasks, setTasks] = React.useState([]);
+  const [detail, setDetail] = React.useState(null);
+  const [search, setSearch] = React.useState("");
+
+  const loadTasks = React.useCallback(async (nextSearch = search) => {
+    const url = new URL("/api/orchestrator/tasks", window.location.origin);
+    url.searchParams.set("limit", "50");
+    if (nextSearch) url.searchParams.set("search", nextSearch);
+    const response = await fetch(url.pathname + url.search);
+    const result = await response.json();
+    setTasks(result.tasks ?? []);
+  }, [search]);
+
+  React.useEffect(() => {
+    void loadTasks("");
+  }, []);
+
+  const updateSearch = (value) => {
+    setSearch(value);
+    void loadTasks(value);
+  };
+
+  const openTask = async (task) => {
+    const response = await fetch("/api/orchestrator/tasks/" + encodeURIComponent(task.id));
+    setDetail(await response.json());
+  };
+
+  const archiveTask = async () => {
+    if (!detail?.id) return;
+    await fetch("/api/orchestrator/tasks/" + encodeURIComponent(detail.id) + "/archive", { method: "POST" });
+    await loadTasks(search);
+  };
+
+  const reopenTask = async () => {
+    if (!detail?.id) return;
+    await fetch("/api/orchestrator/tasks/" + encodeURIComponent(detail.id) + "/reopen", { method: "POST" });
+    const response = await fetch("/api/orchestrator/tasks/" + encodeURIComponent(detail.id));
+    setDetail(await response.json());
+    await loadTasks(search);
+  };
+
+  return React.createElement(
+    "section",
+    {
+      "aria-label": viewMeta.label,
+      "data-testid": "chat-widget-orchestrator",
+      style: { minHeight: "100vh", padding: 24 }
+    },
+    React.createElement("h1", null, viewMeta.label),
+    React.createElement("p", null, viewMeta.pluginName + " dynamic view smoke surface is ready."),
+    React.createElement("input", {
+      placeholder: "Search tasks",
+      value: search,
+      onChange: (event) => updateSearch(event.target.value)
+    }),
+    React.createElement(
+      "div",
+      null,
+      ...tasks.map((task) =>
+        React.createElement(
+          "button",
+          {
+            key: task.id,
+            type: "button",
+            onClick: () => void openTask(task),
+            style: { display: "block", marginTop: 8 }
+          },
+          task.title + " " + statusLabel(task)
+        )
+      )
+    ),
+    detail && React.createElement(
+      "article",
+      { "aria-label": "Task detail", style: { marginTop: 16 } },
+      React.createElement("h2", null, detail.title),
+      React.createElement("p", null, detail.summary ?? detail.originalRequest ?? ""),
+      ...(detail.acceptanceCriteria ?? []).map((item) => React.createElement("p", { key: item }, item)),
+      ...(detail.sessions ?? []).map((session) =>
+        React.createElement(
+          "div",
+          { key: session.id },
+          React.createElement("span", null, session.label),
+          React.createElement("span", null, (session.framework ?? "") + " (" + (session.providerSource ?? "") + ")")
+        )
+      ),
+      ...(detail.artifacts ?? []).map((artifact) => React.createElement("p", { key: artifact.id }, artifact.title)),
+      ...(detail.pendingDecisions ?? []).map((decision) => React.createElement("p", { key: decision.sessionId }, decision.promptText)),
+      ...(detail.events ?? []).map((event) => React.createElement("p", { key: event.id }, event.summary)),
+      ...(detail.transcripts ?? []).map((transcript) => React.createElement("p", { key: transcript.id }, transcript.content)),
+      detail.status === "archived"
+        ? React.createElement("button", { type: "button", onClick: () => void reopenTask() }, "Reopen")
+        : React.createElement("button", { type: "button", onClick: () => void archiveTask() }, "Delete")
+    )
+  );
+}
+
+export { SmokeView as ${exportName} };
+export default SmokeView;
+export async function interact(capability, params = {}) {
+  return { ok: true, viewId: viewMeta.id, viewType: viewMeta.viewType, capability, params };
+}
+`;
+}
+
+function smokeGenericViewBundleSource(view, exportName) {
+  const label = JSON.stringify(view.label);
+  const id = JSON.stringify(view.id);
+  const viewType = JSON.stringify(view.viewType);
+  const pluginName = JSON.stringify(view.pluginName);
+  return `import React from "react";
+
+const viewMeta = {
+  id: ${id},
+  label: ${label},
+  viewType: ${viewType},
+  pluginName: ${pluginName}
+};
+
+function SmokeView() {
+  return React.createElement(
+    "section",
+    { "aria-label": viewMeta.label, style: { minHeight: "100vh", padding: 24 } },
+    React.createElement("h1", null, viewMeta.label),
+    React.createElement("p", null, viewMeta.pluginName + " dynamic view smoke surface is ready."),
+    React.createElement("button", { type: "button" }, "Refresh view"),
+    React.createElement("input", { "aria-label": viewMeta.label + " input", defaultValue: viewMeta.id })
+  );
+}
+
+export { SmokeView as ${exportName} };
+export default SmokeView;
+export async function interact(capability, params = {}) {
+  return { ok: true, viewId: viewMeta.id, viewType: viewMeta.viewType, capability, params };
+}
+`;
+}
+
+function smokeViewBundleSource(view) {
+  const exportName = safeComponentExportName(view.componentExport);
+  if (view.viewType === "tui") {
+    return smokeTuiViewBundleSource(view, exportName);
+  }
+  if (view.id === "screenshare") {
+    return smokeScreenshareBundleSource(view, exportName);
+  }
+  if (view.id === "task-coordinator") {
+    return smokeTaskCoordinatorBundleSource(view, exportName);
+  }
+  return smokeGenericViewBundleSource(view, exportName);
+}
+
+function sendSmokeViewAsset(req, res, url, view, subResource) {
+  const bundleDir = path.join(
+    repoRoot,
+    "plugins",
+    view._smokePluginDirName,
+    "dist",
+    "views",
+  );
+  const assetPath = path.resolve(bundleDir, decodeURIComponent(subResource));
+  const relative = path.relative(bundleDir, assetPath);
+  if (
+    relative.startsWith("..") ||
+    path.isAbsolute(relative) ||
+    relative === ""
+  ) {
+    sendJson(req, res, 400, { error: "Malformed view asset path" });
+    return;
+  }
+  const hostExternalSpecifiers = parseHostExternalSpecifiers(url);
+  if (!existsSync(assetPath)) {
+    if (subResource === "bundle.js") {
+      const source = smokeViewBundleSource(view);
+      const body =
+        hostExternalSpecifiers.length > 0
+          ? rewriteHostExternalImports(source, hostExternalSpecifiers)
+          : source;
+      sendBinary(
+        req,
+        res,
+        200,
+        "application/javascript; charset=utf-8",
+        Buffer.from(body, "utf8"),
+      );
+      return;
+    }
+    sendJson(req, res, 404, { error: `View asset not found: ${subResource}` });
+    return;
+  }
+  const rawBody = readFileSync(assetPath);
+  const body =
+    hostExternalSpecifiers.length > 0 &&
+    contentTypeForSmokeViewAsset(assetPath).startsWith("application/javascript")
+      ? Buffer.from(
+          rewriteHostExternalImports(
+            rawBody.toString("utf8"),
+            hostExternalSpecifiers,
+          ),
+          "utf8",
+        )
+      : rawBody;
+  sendBinary(req, res, 200, contentTypeForSmokeViewAsset(assetPath), body);
+}
+
 function sendSseHeaders(req, res) {
   applyCors(req, res);
   res.writeHead(200, {
@@ -892,6 +2063,15 @@ function writeSseEvent(res, payload) {
   res.write(`data: ${JSON.stringify(payload)}\n\n`);
 }
 
+function sendReadySseStream(req, res) {
+  sendSseHeaders(req, res);
+  writeSseEvent(res, { type: "ready" });
+  const interval = setInterval(() => {
+    res.write(": heartbeat\n\n");
+  }, 15_000);
+  req.on("close", () => clearInterval(interval));
+}
+
 async function readJsonBody(req) {
   const chunks = [];
   for await (const chunk of req) {
@@ -903,6 +2083,17 @@ async function readJsonBody(req) {
   return JSON.parse(Buffer.concat(chunks).toString("utf8"));
 }
 
+// Consume and discard a request body (binary or irrelevant) so the socket
+// drains cleanly before the response is sent.
+async function drainRequest(req) {
+  await new Promise((resolve) => {
+    req.on("data", () => {});
+    req.on("end", resolve);
+    req.on("error", resolve);
+    req.resume();
+  });
+}
+
 function workbenchOverview() {
   return {
     tasks: [],
@@ -923,140 +2114,1621 @@ function workbenchOverview() {
   };
 }
 
-function streamSettings(payload = {}) {
+const emptyOrchestratorUsage = {
+  inputTokens: 0,
+  outputTokens: 0,
+  reasoningTokens: 0,
+  cacheTokens: 0,
+  totalTokens: 0,
+  costUsd: 0,
+  state: "unavailable",
+  byProvider: [],
+};
+
+function emptyOrchestratorStatus() {
   return {
-    ok: true,
-    settings: {
-      theme: "eliza",
-      avatarIndex: 0,
-      ...payload,
+    taskCount: 0,
+    activeTaskCount: 0,
+    pausedTaskCount: 0,
+    blockedTaskCount: 0,
+    validatingTaskCount: 0,
+    sessionCount: 0,
+    activeSessionCount: 0,
+    usage: emptyOrchestratorUsage,
+    byStatus: {
+      open: 0,
+      active: 0,
+      waiting_on_user: 0,
+      blocked: 0,
+      validating: 0,
+      done: 0,
+      failed: 0,
+      archived: 0,
+      interrupted: 0,
     },
   };
 }
 
-const sockets = new Set();
-const server = http.createServer(async (req, res) => {
-  const url = new URL(
-    req.url ?? "/",
-    `http://${req.headers.host ?? `127.0.0.1:${port}`}`,
-  );
+function emptyTrajectoryList(url) {
+  return {
+    trajectories: [],
+    total: 0,
+    offset: Number(url.searchParams.get("offset") ?? 0),
+    limit: Number(url.searchParams.get("limit") ?? 50),
+  };
+}
 
-  if (req.method === "OPTIONS") {
-    sendEmpty(req, res, 204);
-    return;
-  }
+function orchestratorUsage(overrides = {}) {
+  const createdAt = overrides.createdAt ?? new Date().toISOString();
+  return {
+    inputTokens: 0,
+    outputTokens: 0,
+    reasoningTokens: 0,
+    cacheTokens: 0,
+    totalTokens: 0,
+    costUsd: 0,
+    state: "unavailable",
+    usageState: "unavailable",
+    byProvider: [],
+    metadata: {},
+    createdAt,
+    updatedAt: overrides.updatedAt ?? createdAt,
+    ...overrides,
+  };
+}
 
-  if (req.method === "HEAD" && url.pathname === "/api/avatar/vrm") {
-    sendEmpty(req, res, 404);
-    return;
-  }
+function createDemoOrchestratorState() {
+  const startedAtMs = Date.now();
+  const startedAt = new Date(startedAtMs).toISOString();
+  const richUsage = orchestratorUsage({
+    inputTokens: 8400,
+    outputTokens: 2600,
+    reasoningTokens: 1345,
+    totalTokens: 12_345,
+    costUsd: 0.42,
+    state: "measured",
+    usageState: "measured",
+    byProvider: [
+      {
+        provider: "cerebras",
+        model: "gpt-oss-120b",
+        inputTokens: 8400,
+        outputTokens: 2600,
+        reasoningTokens: 1345,
+        cacheTokens: 0,
+        totalTokens: 12_345,
+        costUsd: 0.42,
+        state: "measured",
+      },
+      {
+        provider: "codex",
+        model: "codex-cli",
+        inputTokens: 1200,
+        outputTokens: 900,
+        reasoningTokens: 0,
+        cacheTokens: 0,
+        totalTokens: 2100,
+        costUsd: 0,
+        state: "estimated",
+      },
+    ],
+    createdAt: startedAt,
+    updatedAt: startedAt,
+  });
+  const detail = createDemoTaskDetail({
+    id: "smoke-task-1",
+    title: "Build Kanban planner app",
+    status: "active",
+    priority: "urgent",
+    goal: "Build and verify a tiny Kanban planner app with accessible columns, cards, and persistence.",
+    originalRequest:
+      "Use Codex plus Cerebras gpt-oss-120b to build a planner app.",
+    summary: "Codex has generated files; Cerebras is reviewing UX.",
+    sessionCount: 2,
+    activeSessionCount: 2,
+    latestSessionId: "session-codex",
+    latestSessionLabel: "Codex Builder",
+    latestWorkdir: "/tmp/orchestrator-kanban",
+    latestRepo: "/home/nubs/Git/iqlabs/eliza-labs/eliza",
+    latestActivityAt: startedAtMs,
+    createdAt: startedAt,
+    updatedAt: startedAt,
+    acceptanceCriteria: [
+      "Planner renders three workflow columns",
+      "Cards can be created and moved",
+      "Generated files pass syntax checks",
+    ],
+    currentPlan: {
+      summary: "Build, review, and verify the Kanban planner.",
+      steps: [
+        { title: "Generate app shell", status: "completed" },
+        { title: "Review visual affordances", status: "in_progress" },
+        { title: "Run browser smoke checks", status: "pending" },
+      ],
+    },
+    planRevisions: [
+      {
+        id: "plan-rev-1",
+        threadId: "smoke-task-1",
+        plan: {
+          summary: "Build, review, and verify the Kanban planner.",
+          steps: [
+            { title: "Generate app shell", status: "completed" },
+            { title: "Review visual affordances", status: "in_progress" },
+            { title: "Run browser smoke checks", status: "pending" },
+          ],
+        },
+        basePlanRevisionId: null,
+        editSummary: null,
+        createdBy: "system",
+        metadata: {},
+        timestamp: startedAtMs,
+        createdAt: startedAt,
+      },
+    ],
+    providerPolicy: {
+      preferredFramework: "codex",
+      providerSource: "cerebras",
+      model: "gpt-oss-120b",
+    },
+    sessions: [
+      {
+        id: "session-codex-record",
+        threadId: "smoke-task-1",
+        sessionId: "session-codex",
+        label: "Codex Builder",
+        status: "running",
+        framework: "codex",
+        providerSource: "local-auth",
+        model: "codex-cli",
+        originalTask:
+          "Generate the planner shell and persist card movement locally.",
+        workdir: "/tmp/orchestrator-kanban",
+        repo: "/home/nubs/Git/iqlabs/eliza-labs/eliza",
+        activeTool: "write",
+        decisionCount: 0,
+        autoResolvedCount: 0,
+        registeredAt: startedAtMs,
+        lastActivityAt: startedAtMs,
+        idleCheckCount: 0,
+        taskDelivered: true,
+        completionSummary: null,
+        lastSeenDecisionIndex: 0,
+        lastInputSentAt: null,
+        stoppedAt: null,
+        inputTokens: 1200,
+        outputTokens: 900,
+        reasoningTokens: 0,
+        totalTokens: 2100,
+        cacheTokens: 0,
+        costUsd: 0,
+        usageState: "estimated",
+        metadata: {},
+        createdAt: startedAt,
+        updatedAt: startedAt,
+      },
+      {
+        id: "session-cerebras-record",
+        threadId: "smoke-task-1",
+        sessionId: "session-cerebras",
+        label: "Cerebras Reviewer",
+        status: "running",
+        framework: "eliza",
+        providerSource: "cerebras",
+        model: "gpt-oss-120b",
+        originalTask:
+          "Review the planner visual affordances and interaction model.",
+        workdir: "/tmp/orchestrator-kanban",
+        repo: "/home/nubs/Git/iqlabs/eliza-labs/eliza",
+        activeTool: "review",
+        decisionCount: 0,
+        autoResolvedCount: 0,
+        registeredAt: startedAtMs,
+        lastActivityAt: startedAtMs,
+        idleCheckCount: 0,
+        taskDelivered: true,
+        completionSummary: null,
+        lastSeenDecisionIndex: 0,
+        lastInputSentAt: null,
+        stoppedAt: null,
+        inputTokens: 8400,
+        outputTokens: 2600,
+        reasoningTokens: 1345,
+        totalTokens: 12_345,
+        cacheTokens: 0,
+        costUsd: 0.42,
+        usageState: "measured",
+        metadata: {},
+        createdAt: startedAt,
+        updatedAt: startedAt,
+      },
+    ],
+    artifacts: [
+      {
+        id: "artifact-index",
+        threadId: "smoke-task-1",
+        sessionId: "session-codex",
+        title: "Kanban planner HTML",
+        artifactType: "file",
+        path: "planner/index.html",
+        uri: null,
+        mimeType: "text/html",
+        verificationStatus: "passed",
+        metadata: {},
+        createdAt: startedAt,
+      },
+      {
+        id: "artifact-test",
+        threadId: "smoke-task-1",
+        sessionId: "session-cerebras",
+        title: "Browser smoke report",
+        artifactType: "verification",
+        path: "reports/kanban-smoke.md",
+        uri: null,
+        mimeType: "text/markdown",
+        verificationStatus: "pending",
+        metadata: {},
+        createdAt: startedAt,
+      },
+    ],
+    usage: richUsage,
+  });
+
+  return {
+    tasks: [detail],
+    messages: [
+      {
+        id: "message-user-1",
+        threadId: "smoke-task-1",
+        sessionId: null,
+        senderKind: "user",
+        direction: "stdout",
+        content: "Create a compact Kanban planner app.",
+        timestamp: startedAtMs - 4000,
+        metadata: {},
+        createdAt: new Date(startedAtMs - 4000).toISOString(),
+      },
+      {
+        id: "message-agent-1",
+        threadId: "smoke-task-1",
+        sessionId: "session-codex",
+        senderKind: "sub_agent",
+        direction: "stdout",
+        content: "Generated the planner shell and wired card movement.",
+        timestamp: startedAtMs - 2000,
+        metadata: {},
+        createdAt: new Date(startedAtMs - 2000).toISOString(),
+      },
+    ],
+    events: [
+      {
+        id: "event-tool-write",
+        threadId: "smoke-task-1",
+        sessionId: "session-codex",
+        eventType: "tool_running",
+        summary: "write planner files",
+        timestamp: startedAtMs - 1000,
+        data: {
+          toolCall: {
+            id: "tool-write-index",
+            title: "write",
+            kind: "edit",
+            status: "completed",
+            rawInput: {
+              path: "planner/index.html",
+              content: '<main id="board"></main>',
+            },
+            output: "Wrote planner/index.html",
+          },
+        },
+        createdAt: new Date(startedAtMs - 1000).toISOString(),
+      },
+      {
+        id: "event-validation",
+        threadId: "smoke-task-1",
+        sessionId: "session-cerebras",
+        eventType: "task_registered",
+        summary: "Cerebras reviewer joined for UX validation",
+        timestamp: startedAtMs - 500,
+        data: {},
+        createdAt: new Date(startedAtMs - 500).toISOString(),
+      },
+    ],
+    nextTaskId: 2,
+    nextMessageId: 2,
+    nextEventId: 2,
+    nextSessionId: 3,
+  };
+}
+
+function createDemoTaskDetail(overrides = {}) {
+  const id = overrides.id ?? "smoke-task-1";
+  const createdAt = overrides.createdAt ?? new Date().toISOString();
+  return {
+    id,
+    title: "Audit orchestrator surface",
+    kind: "coding",
+    status: "open",
+    priority: "high",
+    paused: false,
+    originalRequest: "Audit orchestrator surface",
+    summary: "Created by ui-smoke demo mode.",
+    sessionCount: 0,
+    activeSessionCount: 0,
+    latestSessionId: null,
+    latestSessionLabel: null,
+    latestWorkdir: null,
+    latestRepo: null,
+    latestActivityAt: null,
+    decisionCount: 0,
+    usage: orchestratorUsage(),
+    createdAt,
+    updatedAt: overrides.updatedAt ?? createdAt,
+    closedAt: null,
+    archivedAt: null,
+    goal: "Verify controls, routing, and message flow.",
+    roomId: null,
+    taskRoomId: null,
+    worldId: null,
+    ownerUserId: null,
+    parentTaskId: null,
+    acceptanceCriteria: ["Task appears in rail", "Message posts"],
+    currentPlan: null,
+    providerPolicy: null,
+    lastUserTurnAt: null,
+    lastCoordinatorTurnAt: null,
+    metadata: {},
+    sessions: [],
+    decisions: [],
+    events: [],
+    artifacts: [],
+    messages: [],
+    transcripts: [],
+    planRevisions: [],
+    ...overrides,
+  };
+}
+
+function summarizeDemoTask(detail) {
+  return {
+    id: detail.id,
+    title: detail.title,
+    kind: detail.kind,
+    status: detail.status,
+    priority: detail.priority,
+    paused: detail.paused,
+    originalRequest: detail.originalRequest,
+    summary: detail.summary,
+    sessionCount: detail.sessionCount,
+    activeSessionCount: detail.activeSessionCount,
+    latestSessionId: detail.latestSessionId,
+    latestSessionLabel: detail.latestSessionLabel,
+    latestWorkdir: detail.latestWorkdir,
+    latestRepo: detail.latestRepo,
+    latestActivityAt: detail.latestActivityAt,
+    decisionCount: detail.decisionCount,
+    usage: detail.usage,
+    createdAt: detail.createdAt,
+    updatedAt: detail.updatedAt,
+    closedAt: detail.closedAt,
+    archivedAt: detail.archivedAt,
+  };
+}
+
+function demoOrchestratorStatus(state) {
+  const visibleTasks = state.tasks;
+  const byStatus = {
+    open: 0,
+    active: 0,
+    waiting_on_user: 0,
+    blocked: 0,
+    validating: 0,
+    done: 0,
+    failed: 0,
+    archived: 0,
+    interrupted: 0,
+  };
+  let sessionCount = 0;
+  let activeSessionCount = 0;
+  for (const task of visibleTasks) {
+    if (byStatus[task.status] !== undefined) byStatus[task.status] += 1;
+    sessionCount += Number(task.sessionCount ?? 0);
+    activeSessionCount += Number(task.activeSessionCount ?? 0);
+  }
+  return {
+    taskCount: visibleTasks.length,
+    activeTaskCount: byStatus.active,
+    pausedTaskCount: visibleTasks.filter((task) => task.paused === true).length,
+    blockedTaskCount: byStatus.blocked + byStatus.waiting_on_user,
+    validatingTaskCount: byStatus.validating,
+    sessionCount,
+    activeSessionCount,
+    usage: visibleTasks[0]?.usage ?? emptyOrchestratorUsage,
+    byStatus,
+  };
+}
+
+function demoTaskList(state, url) {
+  const status = url.searchParams.get("status");
+  const includeArchived = url.searchParams.get("includeArchived") === "true";
+  const search = (url.searchParams.get("search") ?? "").toLowerCase();
+  const limit = Math.max(1, Number(url.searchParams.get("limit") ?? 50));
+  return state.tasks
+    .filter((task) => includeArchived || task.status !== "archived")
+    .filter((task) => !status || task.status === status)
+    .filter((task) => {
+      if (!search) return true;
+      return [task.title, task.goal, task.summary, task.originalRequest]
+        .join(" ")
+        .toLowerCase()
+        .includes(search);
+    })
+    .slice(0, limit)
+    .map(summarizeDemoTask);
+}
+
+function demoTimelinePage(state, taskId, url) {
+  const limit =
+    Math.max(1, Number.parseInt(url.searchParams.get("limit") ?? "100", 10)) ||
+    100;
+  const start =
+    Math.max(0, Number.parseInt(url.searchParams.get("cursor") ?? "0", 10)) ||
+    0;
+  const items = [
+    ...state.messages
+      .filter((message) => message.threadId === taskId)
+      .map((message) => ({
+        id: `message:${message.id}`,
+        kind: "message",
+        threadId: message.threadId,
+        sessionId: message.sessionId ?? null,
+        timestamp: message.timestamp,
+        createdAt: message.createdAt,
+        message,
+      })),
+    ...state.events
+      .filter((event) => event.threadId === taskId)
+      .map((event) => ({
+        id: `event:${event.id}`,
+        kind: "event",
+        threadId: event.threadId,
+        sessionId: event.sessionId ?? null,
+        timestamp: event.timestamp,
+        createdAt: event.createdAt,
+        event,
+      })),
+  ].sort((a, b) => Number(b.timestamp) - Number(a.timestamp));
+  const page = items.slice(start, start + limit);
+  const next = start + limit;
+  return {
+    items: page,
+    nextCursor: next < items.length ? String(next) : null,
+  };
+}
+
+function pushDemoEvent(state, taskId, summary, data = {}) {
+  const event = {
+    id: `demo-event-${state.nextEventId++}`,
+    threadId: taskId,
+    sessionId: null,
+    eventType: "operator_action",
+    summary,
+    timestamp: Date.now(),
+    data,
+    createdAt: new Date().toISOString(),
+  };
+  state.events.push(event);
+  return event;
+}
+
+function pushDemoMessage(state, taskId, senderKind, content, sessionId = null) {
+  const message = {
+    id: `demo-message-${state.nextMessageId++}`,
+    threadId: taskId,
+    sessionId,
+    senderKind,
+    direction: "stdout",
+    content,
+    timestamp: Date.now(),
+    metadata: {},
+    createdAt: new Date().toISOString(),
+  };
+  state.messages.push(message);
+  return message;
+}
+
+const demoOrchestratorState = DEMO_ORCHESTRATOR
+  ? createDemoOrchestratorState()
+  : null;
+
+async function handleDemoOrchestratorRoute(req, res, url) {
+  if (!demoOrchestratorState) return false;
+  if (!url.pathname.startsWith("/api/orchestrator")) return false;
+
+  if (req.method === "GET" && url.pathname === "/api/orchestrator/status") {
+    sendJson(req, res, 200, demoOrchestratorStatus(demoOrchestratorState));
+    return true;
+  }
+
+  if (req.method === "GET" && url.pathname === "/api/orchestrator/tasks") {
+    sendJson(req, res, 200, {
+      tasks: demoTaskList(demoOrchestratorState, url),
+    });
+    return true;
+  }
+
+  if (req.method === "POST" && url.pathname === "/api/orchestrator/tasks") {
+    const body = (await readJsonBody(req)) || {};
+    const id = `demo-task-${demoOrchestratorState.nextTaskId++}`;
+    const detail = createDemoTaskDetail({
+      id,
+      title: body.title || "Demo orchestrator task",
+      goal: body.goal || body.originalRequest || body.title || "Demo task",
+      originalRequest:
+        body.originalRequest || body.goal || body.title || "Demo task",
+      priority: body.priority || "normal",
+      acceptanceCriteria: Array.isArray(body.acceptanceCriteria)
+        ? body.acceptanceCriteria
+        : ["Created from the visible local UI"],
+      providerPolicy: body.providerPolicy ?? null,
+      status: "open",
+      summary: "Created locally in demo mode.",
+      currentPlan: {
+        summary: "Demo task created from the local UI.",
+        steps: [
+          { title: "Capture request", status: "completed" },
+          { title: "Assign sub-agent", status: "pending" },
+          { title: "Verify result", status: "pending" },
+        ],
+      },
+    });
+    demoOrchestratorState.tasks.unshift(detail);
+    pushDemoMessage(
+      demoOrchestratorState,
+      id,
+      "user",
+      detail.originalRequest || detail.goal,
+    );
+    pushDemoEvent(demoOrchestratorState, id, "Task created from local demo UI");
+    sendJson(req, res, 200, detail);
+    return true;
+  }
+
+  if (req.method === "POST" && url.pathname === "/api/orchestrator/pause-all") {
+    for (const task of demoOrchestratorState.tasks) task.paused = true;
+    sendJson(req, res, 200, { paused: demoOrchestratorState.tasks.length });
+    return true;
+  }
+
+  if (
+    req.method === "POST" &&
+    url.pathname === "/api/orchestrator/resume-all"
+  ) {
+    for (const task of demoOrchestratorState.tasks) task.paused = false;
+    sendJson(req, res, 200, { resumed: demoOrchestratorState.tasks.length });
+    return true;
+  }
+
+  const taskPath = url.pathname.slice("/api/orchestrator/tasks/".length);
+  if (!taskPath || taskPath === url.pathname) return false;
+  const parts = taskPath.split("/").map((part) => decodeURIComponent(part));
+  const [taskId, action, subId, subAction] = parts;
+  const task = demoOrchestratorState.tasks.find((item) => item.id === taskId);
+
+  if (action === "stream" && req.method === "GET") {
+    sendReadySseStream(req, res);
+    return true;
+  }
+
+  if (!task) {
+    sendJson(req, res, 404, { error: `Task not found: ${taskId}` });
+    return true;
+  }
+
+  if (!action) {
+    if (req.method === "GET") {
+      sendJson(req, res, 200, task);
+      return true;
+    }
+    if (req.method === "PATCH") {
+      const body = (await readJsonBody(req)) || {};
+      Object.assign(task, body, { updatedAt: new Date().toISOString() });
+      sendJson(req, res, 200, task);
+      return true;
+    }
+    if (req.method === "DELETE") {
+      demoOrchestratorState.tasks = demoOrchestratorState.tasks.filter(
+        (item) => item.id !== taskId,
+      );
+      demoOrchestratorState.messages = demoOrchestratorState.messages.filter(
+        (item) => item.threadId !== taskId,
+      );
+      demoOrchestratorState.events = demoOrchestratorState.events.filter(
+        (item) => item.threadId !== taskId,
+      );
+      sendJson(req, res, 200, { deleted: true });
+      return true;
+    }
+  }
+
+  if (action === "messages") {
+    if (req.method === "GET") {
+      sendJson(req, res, 200, {
+        items: demoOrchestratorState.messages.filter(
+          (item) => item.threadId === taskId,
+        ),
+        nextCursor: null,
+      });
+      return true;
+    }
+    if (req.method === "POST") {
+      const body = (await readJsonBody(req)) || {};
+      const content = String(body.content ?? "").trim();
+      if (content) {
+        pushDemoMessage(demoOrchestratorState, taskId, "user", content);
+        pushDemoMessage(
+          demoOrchestratorState,
+          taskId,
+          "orchestrator",
+          `Demo orchestrator received: ${content}`,
+        );
+        pushDemoEvent(demoOrchestratorState, taskId, "Message forwarded");
+        task.summary = "New demo message received from the local UI.";
+        task.updatedAt = new Date().toISOString();
+      }
+      sendJson(req, res, 200, { recorded: true, forwardedTo: [] });
+      return true;
+    }
+  }
+
+  if (action === "events" && req.method === "GET") {
+    sendJson(req, res, 200, {
+      items: demoOrchestratorState.events.filter(
+        (item) => item.threadId === taskId,
+      ),
+      nextCursor: null,
+    });
+    return true;
+  }
+
+  if (action === "timeline" && req.method === "GET") {
+    sendJson(
+      req,
+      res,
+      200,
+      demoTimelinePage(demoOrchestratorState, taskId, url),
+    );
+    return true;
+  }
+
+  if (action === "usage" && req.method === "GET") {
+    sendJson(req, res, 200, task.usage ?? emptyOrchestratorUsage);
+    return true;
+  }
+
+  if (action === "plan-revisions") {
+    if (req.method === "GET") {
+      sendJson(req, res, 200, {
+        items: task.planRevisions ?? [],
+        nextCursor: null,
+      });
+      return true;
+    }
+    if (req.method === "POST") {
+      const body = (await readJsonBody(req)) || {};
+      const revision = {
+        id: `plan-rev-${(task.planRevisions?.length ?? 0) + 1}`,
+        threadId: taskId,
+        plan: body.plan ?? task.currentPlan ?? {},
+        basePlanRevisionId: body.basePlanRevisionId ?? null,
+        editSummary: body.editSummary ?? "Edited in local demo mode",
+        createdBy: body.createdBy ?? "operator",
+        metadata: body.metadata ?? {},
+        timestamp: Date.now(),
+        createdAt: new Date().toISOString(),
+      };
+      task.planRevisions = [revision, ...(task.planRevisions ?? [])];
+      task.currentPlan = revision.plan;
+      sendJson(req, res, 200, revision);
+      return true;
+    }
+  }
+
+  if (action === "agents" && req.method === "POST" && !subId) {
+    const body = (await readJsonBody(req)) || {};
+    const sessionId = `demo-session-${demoOrchestratorState.nextSessionId++}`;
+    const session = {
+      id: `${sessionId}-record`,
+      threadId: taskId,
+      sessionId,
+      label: body.label || "Demo sub-agent",
+      status: "running",
+      framework: body.framework || "codex",
+      providerSource: body.providerSource || "local-demo",
+      model: body.model || "gpt-5.4",
+      originalTask: body.task || "Assist with the demo task.",
+      workdir: body.workdir || task.latestWorkdir || "/tmp/orchestrator-demo",
+      repo: body.repo || task.latestRepo || null,
+      activeTool: "thinking",
+      decisionCount: 0,
+      autoResolvedCount: 0,
+      registeredAt: Date.now(),
+      lastActivityAt: Date.now(),
+      idleCheckCount: 0,
+      taskDelivered: true,
+      completionSummary: null,
+      lastSeenDecisionIndex: 0,
+      lastInputSentAt: null,
+      stoppedAt: null,
+      inputTokens: 0,
+      outputTokens: 0,
+      reasoningTokens: 0,
+      totalTokens: 0,
+      cacheTokens: 0,
+      costUsd: 0,
+      usageState: "estimated",
+      metadata: {},
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+    };
+    task.sessions = [...(task.sessions ?? []), session];
+    task.sessionCount = task.sessions.length;
+    task.activeSessionCount = task.sessions.filter(
+      (item) => item.status === "running",
+    ).length;
+    task.latestSessionId = session.sessionId;
+    task.latestSessionLabel = session.label;
+    task.latestActivityAt = session.lastActivityAt;
+    pushDemoEvent(demoOrchestratorState, taskId, `Added ${session.label}`);
+    sendJson(req, res, 200, task);
+    return true;
+  }
+
+  if (
+    action === "agents" &&
+    subId &&
+    subAction === "stop" &&
+    req.method === "POST"
+  ) {
+    task.sessions = (task.sessions ?? []).map((session) =>
+      session.sessionId === subId
+        ? {
+            ...session,
+            status: "stopped",
+            stoppedAt: Date.now(),
+            activeTool: null,
+            updatedAt: new Date().toISOString(),
+          }
+        : session,
+    );
+    task.activeSessionCount = task.sessions.filter(
+      (item) => item.status === "running",
+    ).length;
+    pushDemoEvent(demoOrchestratorState, taskId, `Stopped agent ${subId}`);
+    sendJson(req, res, 200, { stopped: true });
+    return true;
+  }
+
+  if (req.method === "POST") {
+    const body = (await readJsonBody(req)) || {};
+    if (action === "pause") {
+      task.paused = true;
+      pushDemoEvent(demoOrchestratorState, taskId, "Task paused");
+      sendJson(req, res, 200, task);
+      return true;
+    }
+    if (action === "resume") {
+      task.paused = false;
+      pushDemoEvent(demoOrchestratorState, taskId, "Task resumed");
+      sendJson(req, res, 200, task);
+      return true;
+    }
+    if (action === "archive") {
+      task.status = "archived";
+      task.archivedAt = new Date().toISOString();
+      pushDemoEvent(demoOrchestratorState, taskId, "Task archived");
+      sendJson(req, res, 200, { archived: true });
+      return true;
+    }
+    if (action === "reopen") {
+      task.status = "open";
+      task.archivedAt = null;
+      pushDemoEvent(demoOrchestratorState, taskId, "Task reopened");
+      sendJson(req, res, 200, task);
+      return true;
+    }
+    if (action === "fork") {
+      const forked = createDemoTaskDetail({
+        ...task,
+        id: `demo-task-${demoOrchestratorState.nextTaskId++}`,
+        title: body.title || `Fork of ${task.title}`,
+        goal: body.goal || task.goal,
+        parentTaskId: task.id,
+        status: "open",
+        archivedAt: null,
+        sessions: [],
+        sessionCount: 0,
+        activeSessionCount: 0,
+      });
+      demoOrchestratorState.tasks.unshift(forked);
+      pushDemoEvent(demoOrchestratorState, forked.id, "Task forked");
+      sendJson(req, res, 200, forked);
+      return true;
+    }
+    if (action === "validate") {
+      task.status = body.passed === true ? "done" : "blocked";
+      task.summary = body.summary || task.summary;
+      pushDemoEvent(
+        demoOrchestratorState,
+        taskId,
+        "Validation submitted",
+        body,
+      );
+      sendJson(req, res, 200, task);
+      return true;
+    }
+    if (action === "retry-turn") {
+      pushDemoEvent(
+        demoOrchestratorState,
+        taskId,
+        "Retry turn requested",
+        body,
+      );
+      sendJson(req, res, 200, task);
+      return true;
+    }
+    if (action === "rerun-from-event") {
+      pushDemoEvent(
+        demoOrchestratorState,
+        taskId,
+        "Rerun from event requested",
+        body,
+      );
+      sendJson(req, res, 200, task);
+      return true;
+    }
+    if (action === "restart") {
+      task.status = "active";
+      pushDemoEvent(
+        demoOrchestratorState,
+        taskId,
+        "Task restart requested",
+        body,
+      );
+      sendJson(req, res, 200, task);
+      return true;
+    }
+    if (action === "restart-with-edited-plan") {
+      task.status = "active";
+      if (body.plan && typeof body.plan === "object")
+        task.currentPlan = body.plan;
+      pushDemoEvent(
+        demoOrchestratorState,
+        taskId,
+        "Restart with edited plan requested",
+        body,
+      );
+      sendJson(req, res, 200, task);
+      return true;
+    }
+  }
+
+  sendJson(req, res, 404, {
+    error: `Unhandled demo orchestrator route ${url.pathname}`,
+  });
+  return true;
+}
+
+function streamSettings(payload = {}) {
+  return {
+    ok: true,
+    settings: {
+      theme: "eliza",
+      avatarIndex: 0,
+      ...payload,
+    },
+  };
+}
+
+const databaseRowsByTable = {
+  messages: [
+    {
+      id: "msg-smoke-1",
+      content:
+        "UI smoke database row with https://example.com/smoke-image.png media",
+      roomId: "room-smoke",
+      entityId: "entity-smoke",
+      createdAt: SMOKE_GENERATED_AT,
+    },
+    {
+      id: "msg-smoke-2",
+      content: "UI smoke vector sample row",
+      roomId: "room-smoke",
+      entityId: "entity-smoke",
+      createdAt: SMOKE_GENERATED_AT,
+    },
+  ],
+  memories: [
+    {
+      id: "memory-smoke-1",
+      text: "Deterministic memory fixture for UI smoke.",
+      roomId: "room-smoke",
+      entityId: "entity-smoke",
+      createdAt: SMOKE_GENERATED_AT,
+      dim_0: 0.12,
+      dim_1: 0.34,
+      dim_2: 0.56,
+    },
+  ],
+  media: [
+    {
+      id: "media-smoke-1",
+      url: "https://example.com/smoke-image.png",
+      type: "image",
+      filename: "smoke-image.png",
+      createdAt: SMOKE_GENERATED_AT,
+    },
+  ],
+};
+
+const databaseTables = Object.entries(databaseRowsByTable).map(
+  ([name, rows]) => ({
+    name,
+    schema: "public",
+    rowCount: rows.length,
+    columns: Object.keys(rows[0] ?? {}).map((columnName) => ({
+      name: columnName,
+      type: columnName.startsWith("dim_") ? "double precision" : "text",
+      nullable: false,
+      defaultValue: null,
+      isPrimaryKey: columnName === "id",
+    })),
+  }),
+);
+
+function databaseRowsResponse(tableName, url) {
+  const rows = databaseRowsByTable[tableName] ?? [];
+  const offset = Number(url.searchParams.get("offset") ?? "0");
+  const limit = Number(url.searchParams.get("limit") ?? "50");
+  const sort = url.searchParams.get("sort");
+  const order = url.searchParams.get("order") === "desc" ? "desc" : "asc";
+  const sortedRows = sort
+    ? [...rows].sort((left, right) => {
+        const leftValue = String(left[sort] ?? "");
+        const rightValue = String(right[sort] ?? "");
+        return order === "desc"
+          ? rightValue.localeCompare(leftValue)
+          : leftValue.localeCompare(rightValue);
+      })
+    : rows;
+  const pageRows = sortedRows.slice(offset, offset + limit);
+  return {
+    table: tableName,
+    rows: pageRows,
+    columns: Object.keys(rows[0] ?? {}),
+    total: rows.length,
+    offset,
+    limit,
+  };
+}
+
+function executeDatabaseQueryResult(sql) {
+  const match = /from\s+"?([a-z0-9_-]+)"?/iu.exec(sql ?? "");
+  const tableName =
+    match?.[1] && databaseRowsByTable[match[1]] ? match[1] : "messages";
+  const rows = databaseRowsByTable[tableName] ?? [];
+  return {
+    columns: Object.keys(rows[0] ?? {}),
+    rows,
+    rowCount: rows.length,
+    durationMs: 1,
+  };
+}
+
+const sockets = new Set();
+const server = http.createServer(async (req, res) => {
+  const url = new URL(
+    req.url ?? "/",
+    `http://${req.headers.host ?? `127.0.0.1:${port}`}`,
+  );
+
+  if (req.method === "OPTIONS") {
+    sendEmpty(req, res, 204);
+    return;
+  }
+
+  if (
+    (req.method === "GET" || req.method === "HEAD") &&
+    url.pathname === "/api/avatar/vrm"
+  ) {
+    sendBinary(req, res, 200, "application/octet-stream", SMOKE_VRM);
+    return;
+  }
+
+  if (
+    (req.method === "GET" || req.method === "HEAD") &&
+    url.pathname === "/api/avatar/background"
+  ) {
+    sendBinary(req, res, 200, "image/png", ONE_PIXEL_PNG);
+    return;
+  }
+
+  if (
+    (req.method === "GET" || req.method === "HEAD") &&
+    url.pathname.startsWith("/api/apps/hero/")
+  ) {
+    sendBinary(req, res, 200, "image/png", ONE_PIXEL_PNG);
+    return;
+  }
+
+  if (req.method === "GET" && url.pathname === "/api/commands") {
+    sendJson(req, res, 200, {
+      commands: [],
+      surface: url.searchParams.get("surface"),
+      agentId: null,
+      generatedAt: SMOKE_GENERATED_AT,
+    });
+    return;
+  }
+
+  if (req.method === "GET" && url.pathname === "/api/custom-actions") {
+    sendJson(req, res, 200, { actions: [] });
+    return;
+  }
+
+  if (req.method === "GET" && url.pathname === "/api/notifications") {
+    sendJson(req, res, 200, { notifications: [], unreadCount: 0 });
+    return;
+  }
+
+  if (req.method === "GET" && url.pathname === "/api/views") {
+    const requestedViewType = url.searchParams.get("viewType");
+    const views =
+      requestedViewType === "gui" || requestedViewType === "tui"
+        ? smokeViews.filter((view) => view.viewType === requestedViewType)
+        : smokeViews;
+    sendJson(req, res, 200, { views });
+    return;
+  }
+
+  if (req.method === "GET" && url.pathname === "/api/views/current") {
+    sendJson(req, res, 200, { currentView: null });
+    return;
+  }
+
+  if (
+    (req.method === "GET" || req.method === "HEAD") &&
+    url.pathname.startsWith("/api/views/")
+  ) {
+    const afterPrefix = url.pathname.slice("/api/views/".length);
+    const slashIndex = afterPrefix.indexOf("/");
+    const rawId =
+      slashIndex === -1 ? afterPrefix : afterPrefix.slice(0, slashIndex);
+    const subResource =
+      slashIndex === -1 ? "" : afterPrefix.slice(slashIndex + 1);
+    const id = decodeURIComponent(rawId);
+    const view = smokeViewByRequest(id, url.searchParams.get("viewType"));
+    if (!view) {
+      sendJson(req, res, 404, { error: `View not found: ${id}` });
+      return;
+    }
+    if (subResource === "") {
+      sendJson(req, res, 200, view);
+      return;
+    }
+    if (subResource === "hero") {
+      sendBinary(req, res, 200, "image/png", ONE_PIXEL_PNG);
+      return;
+    }
+    if (subResource === "bundle.js") {
+      sendSmokeViewAsset(req, res, url, view, "bundle.js");
+      return;
+    }
+    sendSmokeViewAsset(req, res, url, view, subResource);
+    return;
+  }
+
+  if (req.method === "POST" && url.pathname.startsWith("/api/views/")) {
+    sendJson(req, res, 200, { ok: true });
+    return;
+  }
+
+  if (req.method === "GET" && url.pathname === "/api/health") {
+    sendJson(req, res, 200, { status: "ok" });
+    return;
+  }
+
+  if (req.method === "GET" && url.pathname === "/api/first-run/status") {
+    sendJson(req, res, 200, { complete: true });
+    return;
+  }
+
+  if (req.method === "GET" && url.pathname === "/api/first-run/options") {
+    sendJson(req, res, 200, {
+      names: [],
+      styles: [],
+      providers: [],
+      cloudProviders: [],
+      models: {
+        nano: [],
+        small: [],
+        medium: [],
+        large: [],
+        mega: [],
+      },
+      inventoryProviders: [],
+      sharedStyleRules: "",
+    });
+    return;
+  }
+
+  if (req.method === "GET" && url.pathname === "/api/auth/status") {
+    sendJson(req, res, 200, {
+      required: false,
+      pairingEnabled: false,
+      expiresAt: null,
+    });
+    return;
+  }
+
+  if (req.method === "GET" && url.pathname === "/api/auth/me") {
+    sendJson(req, res, 200, {
+      identity: stubAuthIdentity,
+      session: stubAuthSession,
+      access: stubAuthAccess,
+    });
+    return;
+  }
+
+  if (req.method === "GET" && url.pathname === "/api/auth/sessions") {
+    sendJson(req, res, 200, {
+      sessions: [
+        {
+          id: stubAuthSession.id,
+          kind: stubAuthSession.kind,
+          ip: "127.0.0.1",
+          userAgent: "Playwright smoke",
+          lastSeenAt: Date.now(),
+          expiresAt: null,
+          current: true,
+        },
+      ],
+    });
+    return;
+  }
+
+  if (req.method === "GET" && url.pathname === "/api/agent/status") {
+    sendJson(req, res, 200, { firstRunComplete: true, status: "running" });
+    return;
+  }
+
+  if (req.method === "POST" && url.pathname === "/api/emote") {
+    const body = (await readJsonBody(req)) || {};
+    sendJson(req, res, 200, {
+      ok: true,
+      emoteId: typeof body.emoteId === "string" ? body.emoteId : null,
+    });
+    return;
+  }
+
+  if (req.method === "GET" && url.pathname === "/api/status") {
+    sendJson(req, res, 200, {
+      state: "running",
+      agentName: "Playwright Smoke",
+      model: "ui-smoke",
+      startup: { phase: "running", attempt: 0 },
+      pendingRestart: false,
+      pendingRestartReasons: [],
+    });
+    return;
+  }
+
+  if (url.pathname === "/api/config") {
+    const config = {
+      cloud: { enabled: false },
+      media: {},
+      // Select the local-inference voice provider so the /chat overlay's
+      // bidirectional loop drives /api/asr/local-inference (in) and
+      // /api/tts/local-inference (out) — both stubbed below.
+      messages: {
+        tts: { provider: "local-inference" },
+        asr: { provider: "local-inference" },
+      },
+      plugins: { entries: {} },
+      ui: {},
+      wallet: {},
+    };
+    if (req.method === "GET") {
+      sendJson(req, res, 200, config);
+      return;
+    }
+    if (req.method === "PUT" || req.method === "PATCH") {
+      const body = (await readJsonBody(req)) || {};
+      sendJson(req, res, 200, {
+        ...config,
+        ...(body && typeof body === "object" && !Array.isArray(body)
+          ? body
+          : {}),
+      });
+      return;
+    }
+  }
+
+  if (req.method === "GET" && url.pathname === "/api/database/status") {
+    sendJson(req, res, 200, {
+      provider: "pglite",
+      connected: true,
+      serverVersion: "16.0-ui-smoke",
+      tableCount: databaseTables.length,
+      pgliteDataDir: null,
+      postgresHost: null,
+    });
+    return;
+  }
+
+  if (req.method === "GET" && url.pathname === "/api/database/config") {
+    sendJson(req, res, 200, {
+      config: {},
+      activeProvider: "pglite",
+      needsRestart: false,
+    });
+    return;
+  }
+
+  if (req.method === "PUT" && url.pathname === "/api/database/config") {
+    sendJson(req, res, 200, {
+      config: (await readJsonBody(req)) || {},
+      activeProvider: "pglite",
+      needsRestart: false,
+    });
+    return;
+  }
+
+  if (req.method === "POST" && url.pathname === "/api/database/test") {
+    sendJson(req, res, 200, {
+      success: true,
+      serverVersion: "16.0-ui-smoke",
+      error: null,
+      durationMs: 1,
+    });
+    return;
+  }
+
+  if (req.method === "GET" && url.pathname === "/api/database/tables") {
+    sendJson(req, res, 200, { tables: databaseTables });
+    return;
+  }
+
+  const databaseRowsMatch = /^\/api\/database\/tables\/([^/]+)\/rows$/.exec(
+    url.pathname,
+  );
+  if (databaseRowsMatch) {
+    const tableName = decodeURIComponent(databaseRowsMatch[1]);
+    if (req.method === "GET") {
+      sendJson(req, res, 200, databaseRowsResponse(tableName, url));
+      return;
+    }
+    if (["POST", "PUT", "DELETE"].includes(req.method ?? "GET")) {
+      sendJson(req, res, 200, {
+        ok: true,
+        table: tableName,
+        row: databaseRowsByTable[tableName]?.[0] ?? null,
+      });
+      return;
+    }
+  }
+
+  if (req.method === "POST" && url.pathname === "/api/database/query") {
+    const body = (await readJsonBody(req)) || {};
+    sendJson(req, res, 200, executeDatabaseQueryResult(String(body.sql ?? "")));
+    return;
+  }
+
+  if (
+    (req.method === "GET" || req.method === "POST") &&
+    url.pathname === "/api/database/vectors/search"
+  ) {
+    const query =
+      req.method === "POST"
+        ? (await readJsonBody(req))?.query
+        : url.searchParams.get("query");
+    sendJson(req, res, 200, {
+      query: typeof query === "string" ? query : "",
+      table: "memories",
+      limit: 10,
+      count: 1,
+      results: [
+        {
+          id: "memory-smoke-1",
+          text: "Deterministic memory fixture for UI smoke.",
+          similarity: 0.98,
+          roomId: "room-smoke",
+          entityId: "entity-smoke",
+          createdAt: SMOKE_GENERATED_AT,
+          tableName: "memories",
+        },
+      ],
+    });
+    return;
+  }
+
+  if (req.method === "GET" && url.pathname === "/api/vincent/status") {
+    sendJson(req, res, 200, {
+      connected: false,
+      connectedAt: null,
+      tradingVenues: ["hyperliquid", "polymarket"],
+    });
+    return;
+  }
 
-  if (req.method === "HEAD" && url.pathname === "/api/avatar/background") {
-    sendEmpty(req, res, 404);
+  if (req.method === "GET" && url.pathname === "/api/vincent/strategy") {
+    sendJson(req, res, 200, { connected: false, strategy: null });
     return;
   }
 
-  if (req.method === "GET" && url.pathname === "/api/health") {
-    sendJson(req, res, 200, { status: "ok" });
+  if (req.method === "GET" && url.pathname === "/api/vincent/trading-profile") {
+    sendJson(req, res, 200, { connected: false, profile: null });
     return;
   }
 
-  if (req.method === "GET" && url.pathname === "/api/onboarding/status") {
-    sendJson(req, res, 200, { complete: true });
+  if (req.method === "GET" && url.pathname === "/api/shopify/status") {
+    sendJson(req, res, 200, { connected: false, shop: null });
+    return;
+  }
+
+  if (req.method === "GET" && url.pathname === "/api/shopify/products") {
+    sendJson(req, res, 200, { products: [], total: 0, page: 1, pageSize: 25 });
+    return;
+  }
+
+  if (req.method === "GET" && url.pathname === "/api/shopify/orders") {
+    sendJson(req, res, 200, { orders: [], total: 0 });
+    return;
+  }
+
+  if (req.method === "GET" && url.pathname === "/api/shopify/inventory") {
+    sendJson(req, res, 200, { items: [], locations: [] });
+    return;
+  }
+
+  if (req.method === "GET" && url.pathname === "/api/shopify/customers") {
+    sendJson(req, res, 200, { customers: [], total: 0 });
+    return;
+  }
+
+  if (req.method === "GET" && url.pathname === "/api/hyperliquid/status") {
+    sendJson(req, res, 200, stubHyperliquidStatus);
+    return;
+  }
+
+  if (req.method === "GET" && url.pathname === "/api/hyperliquid/markets") {
+    sendJson(req, res, 200, stubHyperliquidMarkets);
     return;
   }
 
-  if (req.method === "GET" && url.pathname === "/api/onboarding/options") {
+  if (req.method === "GET" && url.pathname === "/api/hyperliquid/positions") {
     sendJson(req, res, 200, {
-      names: [],
-      styles: [],
-      providers: [],
-      cloudProviders: [],
-      models: {
-        nano: [],
-        small: [],
-        medium: [],
-        large: [],
-        mega: [],
-      },
-      inventoryProviders: [],
-      sharedStyleRules: "",
+      accountAddress: null,
+      positions: [],
+      readBlockedReason:
+        "Connect an account address to read Hyperliquid positions.",
+      fetchedAt: null,
     });
     return;
   }
 
-  if (req.method === "GET" && url.pathname === "/api/auth/status") {
+  if (req.method === "GET" && url.pathname === "/api/hyperliquid/orders") {
     sendJson(req, res, 200, {
-      required: false,
-      pairingEnabled: false,
-      expiresAt: null,
+      accountAddress: null,
+      orders: [],
+      readBlockedReason: "Connect an account address to read open orders.",
+      fetchedAt: null,
     });
     return;
   }
 
-  if (req.method === "GET" && url.pathname === "/api/auth/me") {
+  if (req.method === "GET" && url.pathname === "/api/polymarket/status") {
+    sendJson(req, res, 200, stubPolymarketStatus);
+    return;
+  }
+
+  if (req.method === "GET" && url.pathname === "/api/polymarket/markets") {
     sendJson(req, res, 200, {
-      identity: stubAuthIdentity,
-      session: stubAuthSession,
-      access: stubAuthAccess,
+      markets: [stubPolymarketMarket],
+      source: { api: "gamma", endpoint: "/markets" },
     });
     return;
   }
 
-  if (req.method === "GET" && url.pathname === "/api/auth/sessions") {
+  if (req.method === "GET" && url.pathname === "/api/polymarket/market") {
     sendJson(req, res, 200, {
-      sessions: [
-        {
-          id: stubAuthSession.id,
-          kind: stubAuthSession.kind,
-          ip: "127.0.0.1",
-          userAgent: "Playwright smoke",
-          lastSeenAt: Date.now(),
-          expiresAt: null,
-          current: true,
-        },
-      ],
+      market: stubPolymarketMarket,
+      source: { api: "gamma", endpoint: "/markets" },
     });
     return;
   }
 
-  if (req.method === "GET" && url.pathname === "/api/agent/status") {
-    sendJson(req, res, 200, { onboardingComplete: true, status: "running" });
+  if (req.method === "GET" && url.pathname === "/api/polymarket/orderbook") {
+    sendJson(req, res, 200, {
+      tokenId: url.searchParams.get("token_id") ?? "yes-token",
+      market: stubPolymarketMarket.id,
+      assetId: null,
+      bids: [{ price: "0.71", size: "100" }],
+      asks: [{ price: "0.73", size: "100" }],
+      bestBid: "0.71",
+      bestBidSize: "100",
+      bestAsk: "0.73",
+      bestAskSize: "100",
+      midpoint: "0.72",
+      spread: "0.02",
+      bidLevels: 1,
+      askLevels: 1,
+      lastTradePrice: "0.72",
+      tickSize: "0.01",
+      source: { api: "clob", endpoint: "/book" },
+    });
     return;
   }
 
-  if (req.method === "GET" && url.pathname === "/api/status") {
+  if (req.method === "GET" && url.pathname === "/api/polymarket/orders") {
     sendJson(req, res, 200, {
-      state: "running",
-      startup: { phase: "running", attempt: 0 },
-      pendingRestart: false,
-      pendingRestartReasons: [],
+      enabled: false,
+      reason: "Trading is disabled in UI smoke.",
+      requiredForTrading: [
+        "POLYMARKET_PRIVATE_KEY",
+        "CLOB_API_KEY",
+        "CLOB_API_SECRET",
+        "CLOB_API_PASSPHRASE",
+      ],
     });
     return;
   }
 
-  if (req.method === "GET" && url.pathname === "/api/config") {
+  if (req.method === "GET" && url.pathname === "/api/polymarket/positions") {
     sendJson(req, res, 200, {
-      cloud: { enabled: false },
-      media: {},
-      plugins: { entries: {} },
-      ui: {},
-      wallet: {},
+      positions: [],
+      source: { api: "data", endpoint: "/positions" },
     });
     return;
   }
 
-  if (req.method === "GET" && url.pathname === "/api/vincent/status") {
-    sendJson(req, res, 200, {
-      connected: false,
-      connectedAt: null,
-      tradingVenues: ["hyperliquid", "polymarket"],
+  if (url.pathname === "/api/conversations") {
+    if (req.method === "GET") {
+      sendJson(req, res, 200, { conversations: stubConversations });
+      return;
+    }
+    if (req.method === "POST") {
+      const body = (await readJsonBody(req)) || {};
+      const conversation = createStubConversation({
+        title: body.title,
+        metadata: body.metadata,
+      });
+      sendJson(req, res, 200, { conversation });
+      return;
+    }
+  }
+
+  if (
+    req.method === "POST" &&
+    url.pathname === "/api/conversations/cleanup-empty"
+  ) {
+    const body = (await readJsonBody(req)) || {};
+    const deleted = cleanupEmptyStubConversations({
+      keepId: body.keepId,
     });
+    sendJson(req, res, 200, { deleted });
     return;
   }
 
-  if (req.method === "GET" && url.pathname === "/api/conversations") {
-    sendJson(req, res, 200, { conversations: [] });
+  const conversationMessagesMatch = url.pathname.match(
+    /^\/api\/conversations\/([^/]+)\/messages(?:\/(stream|truncate))?$/,
+  );
+  if (conversationMessagesMatch) {
+    const conversationId = decodeURIComponent(conversationMessagesMatch[1]);
+    const action = conversationMessagesMatch[2] ?? null;
+    const conversation = findStubConversation(conversationId);
+    if (!conversation) {
+      sendJson(req, res, 404, { error: "Conversation not found" });
+      return;
+    }
+
+    if (req.method === "GET" && action === null) {
+      sendJson(req, res, 200, {
+        messages: stubConversationMessages.get(conversationId) ?? [],
+      });
+      return;
+    }
+
+    if (req.method === "POST" && action === "truncate") {
+      stubConversationMessages.set(conversationId, []);
+      conversation.updatedAt = nowIso();
+      sendJson(req, res, 200, { ok: true, messages: [] });
+      return;
+    }
+
+    if (req.method === "POST" && action === "stream") {
+      const body = (await readJsonBody(req)) || {};
+      appendStubMessage(conversationId, createStubMessage("user", body.text));
+      const text = createDeterministicAssistantText({
+        body,
+        conversationId,
+        transport: "sse",
+      });
+      appendStubMessage(conversationId, createStubMessage("assistant", text));
+      sendSseHeaders(req, res);
+      writeSseEvent(res, { type: "token", text, fullText: text });
+      writeSseEvent(res, { type: "done", fullText: text, agentName: "Eliza" });
+      res.end();
+      return;
+    }
+
+    if (req.method === "POST" && action === null) {
+      const body = (await readJsonBody(req)) || {};
+      appendStubMessage(conversationId, createStubMessage("user", body.text));
+      const text = createDeterministicAssistantText({
+        body,
+        conversationId,
+        transport: "json",
+      });
+      appendStubMessage(conversationId, createStubMessage("assistant", text));
+      sendJson(req, res, 200, { text, agentName: "Eliza" });
+      return;
+    }
+  }
+
+  const conversationMatch = url.pathname.match(
+    /^\/api\/conversations\/([^/]+)$/,
+  );
+  if (conversationMatch) {
+    const conversationId = decodeURIComponent(conversationMatch[1]);
+    const conversation = findStubConversation(conversationId);
+    if (!conversation) {
+      sendJson(req, res, 404, { error: "Conversation not found" });
+      return;
+    }
+    if (req.method === "PATCH") {
+      const body = (await readJsonBody(req)) || {};
+      if (typeof body.title === "string" && body.title.trim().length > 0) {
+        conversation.title = body.title.trim();
+      }
+      if (
+        Object.hasOwn(body, "metadata") &&
+        body.metadata &&
+        typeof body.metadata === "object" &&
+        !Array.isArray(body.metadata)
+      ) {
+        conversation.metadata = body.metadata;
+      }
+      conversation.updatedAt = nowIso();
+      sendJson(req, res, 200, { conversation });
+      return;
+    }
+    if (req.method === "DELETE") {
+      const index = stubConversations.findIndex(
+        (item) => item.id === conversationId,
+      );
+      if (index >= 0) stubConversations.splice(index, 1);
+      stubConversationMessages.delete(conversationId);
+      sendJson(req, res, 200, { ok: true });
+      return;
+    }
+  }
+
+  const conversationGreetingMatch = url.pathname.match(
+    /^\/api\/conversations\/([^/]+)\/greeting$/,
+  );
+  if (req.method === "POST" && conversationGreetingMatch) {
+    const conversationId = decodeURIComponent(conversationGreetingMatch[1]);
+    if (!findStubConversation(conversationId)) {
+      sendJson(req, res, 404, { error: "Conversation not found" });
+      return;
+    }
+    sendJson(req, res, 200, {
+      text: "What would you like to check?",
+      agentName: "Eliza",
+      generated: false,
+      persisted: true,
+    });
     return;
   }
 
@@ -1085,6 +3757,16 @@ const server = http.createServer(async (req, res) => {
     return;
   }
 
+  if (req.method === "GET" && url.pathname === "/api/runtime/mode") {
+    sendJson(req, res, 200, {
+      mode: "local",
+      deploymentRuntime: "local",
+      isRemoteController: false,
+      remoteApiBaseConfigured: false,
+    });
+    return;
+  }
+
   if (req.method === "GET" && url.pathname === "/api/memories/stats") {
     sendJson(req, res, 200, stubMemoryStats);
     return;
@@ -1224,46 +3906,325 @@ const server = http.createServer(async (req, res) => {
     }
   }
 
-  if (req.method === "GET" && url.pathname === "/api/character") {
-    sendJson(req, res, 200, { character: stubCharacter, agentName: "Eliza" });
+  if (req.method === "GET" && url.pathname === "/api/character") {
+    sendJson(req, res, 200, { character: stubCharacter, agentName: "Eliza" });
+    return;
+  }
+
+  if (req.method === "GET" && url.pathname === "/api/character/history") {
+    sendJson(req, res, 200, { history: [], total: 0 });
+    return;
+  }
+
+  if (req.method === "GET" && url.pathname === "/api/character/experiences") {
+    sendJson(req, res, 200, {
+      data: stubExperiences,
+      total: stubExperiences.length,
+    });
+    return;
+  }
+
+  if (req.method === "GET" && url.pathname === "/api/relationships/activity") {
+    sendJson(req, res, 200, { activity: [] });
+    return;
+  }
+
+  if (req.method === "GET" && url.pathname === "/api/documents") {
+    sendJson(req, res, 200, {
+      documents: [],
+      total: 0,
+      limit: parsePositiveInt(url.searchParams.get("limit"), 100),
+      offset: parsePositiveInt(url.searchParams.get("offset"), 0),
+    });
+    return;
+  }
+
+  if (req.method === "GET" && url.pathname === "/api/voice/profiles") {
+    sendJson(req, res, 200, { profiles: [] });
+    return;
+  }
+
+  if (req.method === "GET" && url.pathname === "/api/subscription/status") {
+    sendJson(req, res, 200, { providers: [] });
+    return;
+  }
+
+  if (req.method === "GET" && url.pathname === "/api/update/status") {
+    sendJson(req, res, 200, {
+      currentVersion: "0.0.0-ui-smoke",
+      channel: "stable",
+      installMethod: "source",
+      updateAuthority: "manual",
+      nextAction: "manual",
+      canAutoUpdate: false,
+      canExecuteUpdate: false,
+      remoteDisplay: false,
+      updateCommand: null,
+      updateInstructions: null,
+      updateAvailable: false,
+      latestVersion: "0.0.0-ui-smoke",
+      channels: {
+        stable: "0.0.0-ui-smoke",
+        beta: "0.0.0-ui-smoke",
+        nightly: "0.0.0-ui-smoke",
+      },
+      distTags: {},
+      lastCheckAt: null,
+      error: null,
+    });
+    return;
+  }
+
+  if (req.method === "GET" && url.pathname === "/api/permissions") {
+    const permission = {
+      id: "shell",
+      status: "granted",
+      lastChecked: Date.now(),
+      canRequest: false,
+      platform: process.platform,
+    };
+    sendJson(req, res, 200, {
+      shell: permission,
+      notifications: { ...permission, id: "notifications" },
+      microphone: { ...permission, id: "microphone" },
+      camera: { ...permission, id: "camera" },
+      "screen-capture": { ...permission, id: "screen-capture" },
+      accessibility: { ...permission, id: "accessibility" },
+      "website-blocking": {
+        ...permission,
+        id: "website-blocking",
+        status: "not-applicable",
+      },
+      _platform: process.platform,
+      _shellEnabled: true,
+    });
+    return;
+  }
+
+  if (req.method === "GET" && url.pathname === "/api/permissions/shell") {
+    sendJson(req, res, 200, {
+      id: "shell",
+      status: "granted",
+      lastChecked: Date.now(),
+      canRequest: false,
+      platform: process.platform,
+    });
+    return;
+  }
+
+  if (
+    (req.method === "GET" || req.method === "PUT") &&
+    url.pathname === "/api/secrets/manager/preferences"
+  ) {
+    if (req.method === "PUT") {
+      await readJsonBody(req);
+    }
+    sendJson(req, res, 200, {
+      preferences: { enabled: ["in-house"], routing: {} },
+    });
+    return;
+  }
+
+  if (
+    req.method === "GET" &&
+    url.pathname === "/api/secrets/manager/backends"
+  ) {
+    sendJson(req, res, 200, {
+      backends: [
+        {
+          id: "in-house",
+          label: "Local (encrypted)",
+          available: true,
+          signedIn: true,
+          detail: "UI smoke local vault",
+          authMode: null,
+        },
+      ],
+    });
+    return;
+  }
+
+  // Secrets-manager modal load endpoints — the modal's load() requires all of
+  // these to be ok or it shows an error banner instead of the tabs/add-secret
+  // form. Minimal valid shapes (vault-tabs/types.ts) so the modal renders.
+  if (
+    req.method === "GET" &&
+    url.pathname === "/api/secrets/manager/backends"
+  ) {
+    sendJson(req, res, 200, {
+      backends: [{ id: "in-house", label: "In-House Vault", available: true }],
+    });
+    return;
+  }
+  if (
+    req.method === "GET" &&
+    url.pathname === "/api/secrets/manager/preferences"
+  ) {
+    sendJson(req, res, 200, { preferences: { enabled: ["in-house"] } });
+    return;
+  }
+  if (
+    req.method === "GET" &&
+    url.pathname === "/api/secrets/manager/install/methods"
+  ) {
+    sendJson(req, res, 200, { methods: {} });
+    return;
+  }
+  if (req.method === "GET" && url.pathname === "/api/secrets/routing") {
+    sendJson(req, res, 200, { config: { rules: [] } });
+    return;
+  }
+
+  if (req.method === "GET" && url.pathname === "/api/secrets/inventory") {
+    const category = url.searchParams.get("category");
+    sendJson(req, res, 200, {
+      entries:
+        category === "wallet"
+          ? [
+              {
+                key: "EVM_PRIVATE_KEY",
+                label: "EVM private key",
+                category: "wallet",
+                backend: "in-house",
+                isSet: true,
+                updatedAt: SMOKE_GENERATED_AT,
+              },
+              {
+                key: "SOLANA_PRIVATE_KEY",
+                label: "Solana private key",
+                category: "wallet",
+                backend: "in-house",
+                isSet: true,
+                updatedAt: SMOKE_GENERATED_AT,
+              },
+            ]
+          : [],
+    });
+    return;
+  }
+
+  const secretInventoryMatch = /^\/api\/secrets\/inventory\/([^/]+)$/.exec(
+    url.pathname,
+  );
+  if (secretInventoryMatch) {
+    const key = decodeURIComponent(secretInventoryMatch[1]);
+    if (req.method === "GET") {
+      sendJson(req, res, 200, {
+        ok: true,
+        value: key.includes("SOLANA")
+          ? "5HueCGU8rMjxEXxiPuD5BDuRa"
+          : "0x0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef",
+        source: "bare",
+      });
+      return;
+    }
+    if (req.method === "PUT" || req.method === "DELETE") {
+      if (req.method === "PUT") {
+        await readJsonBody(req);
+      }
+      sendJson(req, res, 200, { ok: true, key });
+      return;
+    }
+  }
+
+  if (req.method === "GET" && url.pathname === "/api/wallet/addresses") {
+    sendJson(req, res, 200, { evmAddress: null, solanaAddress: null });
+    return;
+  }
+
+  if (req.method === "GET" && url.pathname === "/api/wallet/config") {
+    sendJson(req, res, 200, emptyWalletConfig);
+    return;
+  }
+
+  if (req.method === "PUT" && url.pathname === "/api/wallet/config") {
+    const body = (await readJsonBody(req)) || {};
+    sendJson(req, res, 200, {
+      ...emptyWalletConfig,
+      selectedRpcProviders:
+        body && typeof body === "object" && "selections" in body
+          ? body.selections
+          : emptyWalletConfig.selectedRpcProviders,
+    });
     return;
   }
 
-  if (req.method === "GET" && url.pathname === "/api/character/history") {
-    sendJson(req, res, 200, { history: [], total: 0 });
+  if (req.method === "GET" && url.pathname === "/api/wallet/keys") {
+    sendJson(req, res, 200, {
+      evmPrivateKeySet: true,
+      solanaPrivateKeySet: true,
+      evmAddress: "0x1234567890abcdef1234567890abcdef12345678",
+      solanaAddress: "So11111111111111111111111111111111111111112",
+    });
     return;
   }
 
-  if (req.method === "GET" && url.pathname === "/api/character/experiences") {
+  if (req.method === "GET" && url.pathname === "/api/wallet/os-store") {
     sendJson(req, res, 200, {
-      data: stubExperiences,
-      total: stubExperiences.length,
+      available: true,
+      backend: "in-house",
+      evmKeyInOsStore: true,
+      solanaKeyInOsStore: true,
+      envKeysPresent: false,
     });
     return;
   }
 
-  if (req.method === "GET" && url.pathname === "/api/relationships/activity") {
-    sendJson(req, res, 200, { activity: [] });
+  if (req.method === "POST" && url.pathname === "/api/wallet/os-store") {
+    const body = (await readJsonBody(req)) || {};
+    sendJson(req, res, 200, { ok: true, action: body.action ?? null });
     return;
   }
 
-  if (req.method === "GET" && url.pathname === "/api/documents") {
+  if (req.method === "POST" && url.pathname === "/api/wallet/refresh-cloud") {
     sendJson(req, res, 200, {
-      documents: [],
-      total: 0,
-      limit: parsePositiveInt(url.searchParams.get("limit"), 100),
-      offset: parsePositiveInt(url.searchParams.get("offset"), 0),
+      ok: true,
+      imported: [],
+      warnings: [],
     });
     return;
   }
 
-  if (req.method === "GET" && url.pathname === "/api/wallet/addresses") {
-    sendJson(req, res, 200, { evmAddress: null, solanaAddress: null });
+  if (req.method === "POST" && url.pathname === "/api/wallet/primary") {
+    const body = (await readJsonBody(req)) || {};
+    sendJson(req, res, 200, { ok: true, ...body });
     return;
   }
 
-  if (req.method === "GET" && url.pathname === "/api/wallet/config") {
-    sendJson(req, res, 200, emptyWalletConfig);
+  if (req.method === "POST" && url.pathname === "/api/wallet/generate") {
+    const body = (await readJsonBody(req)) || {};
+    sendJson(req, res, 200, {
+      ok: true,
+      chain: body.chain ?? "evm",
+      source: body.source ?? "local",
+      address:
+        body.chain === "solana"
+          ? "So11111111111111111111111111111111111111112"
+          : "0x1234567890abcdef1234567890abcdef12345678",
+    });
+    return;
+  }
+
+  if (req.method === "POST" && url.pathname === "/api/wallet/export") {
+    await readJsonBody(req);
+    sendJson(req, res, 200, {
+      evmPrivateKey:
+        "0x0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef",
+      solanaPrivateKey: "5HueCGU8rMjxEXxiPuD5BDuRa",
+    });
+    return;
+  }
+
+  if (
+    req.method === "POST" &&
+    url.pathname === "/api/wallet/production-defaults"
+  ) {
+    await readJsonBody(req);
+    sendJson(req, res, 200, {
+      ok: true,
+      updated: true,
+      warnings: [],
+    });
     return;
   }
 
@@ -1535,6 +4496,101 @@ const server = http.createServer(async (req, res) => {
     return;
   }
 
+  if (await handleDemoOrchestratorRoute(req, res, url)) {
+    return;
+  }
+
+  if (req.method === "GET" && url.pathname === "/api/orchestrator/status") {
+    sendJson(req, res, 200, emptyOrchestratorStatus());
+    return;
+  }
+
+  if (req.method === "GET" && url.pathname === "/api/orchestrator/tasks") {
+    sendJson(req, res, 200, { tasks: [] });
+    return;
+  }
+
+  const orchestratorTaskMatch =
+    /^\/api\/orchestrator\/tasks\/([^/]+)(?:\/([^/]+))?$/.exec(url.pathname);
+  if (orchestratorTaskMatch) {
+    const [, taskId, action] = orchestratorTaskMatch;
+    if (req.method === "GET" && action === "stream") {
+      sendReadySseStream(req, res);
+      return;
+    }
+    if (req.method === "GET" && action === "messages") {
+      sendJson(req, res, 200, { items: [], nextCursor: null });
+      return;
+    }
+    if (req.method === "GET" && action === "events") {
+      sendJson(req, res, 200, { items: [], nextCursor: null });
+      return;
+    }
+    if (req.method === "GET" && action === "timeline") {
+      sendJson(req, res, 200, { items: [], nextCursor: null });
+      return;
+    }
+    if (req.method === "GET" && action === "usage") {
+      sendJson(req, res, 200, emptyOrchestratorUsage);
+      return;
+    }
+    if (req.method === "GET" && !action) {
+      sendJson(req, res, 404, { error: `Task not found: ${taskId}` });
+      return;
+    }
+    if (req.method === "POST") {
+      sendJson(req, res, 200, { ok: true, id: taskId });
+      return;
+    }
+  }
+
+  if (req.method === "GET" && url.pathname === "/api/trajectories/stats") {
+    sendJson(req, res, 200, {
+      totalTrajectories: 0,
+      totalLlmCalls: 0,
+      totalProviderAccesses: 0,
+      totalPromptTokens: 0,
+      totalCompletionTokens: 0,
+      averageDurationMs: 0,
+      bySource: {},
+      byModel: {},
+    });
+    return;
+  }
+
+  if (req.method === "GET" && url.pathname === "/api/trajectories/config") {
+    sendJson(req, res, 200, { enabled: false });
+    return;
+  }
+
+  if (req.method === "GET" && url.pathname === "/api/trajectories/latest") {
+    sendJson(req, res, 200, { trajectory: null });
+    return;
+  }
+
+  if (req.method === "GET" && url.pathname === "/api/trajectories") {
+    sendJson(req, res, 200, emptyTrajectoryList(url));
+    return;
+  }
+
+  const trajectoryDetailMatch = /^\/api\/trajectories\/([^/]+)$/.exec(
+    url.pathname,
+  );
+  if (req.method === "GET" && trajectoryDetailMatch) {
+    sendJson(req, res, 200, {
+      trajectory: {
+        id: decodeURIComponent(trajectoryDetailMatch[1] ?? "unknown"),
+        status: "completed",
+        llmCallCount: 0,
+      },
+      llmCalls: [],
+      providerAccesses: [],
+      toolEvents: [],
+      evaluationEvents: [],
+    });
+    return;
+  }
+
   if (req.method === "GET" && url.pathname === "/api/coding-agents/preflight") {
     sendJson(req, res, 200, {
       ok: true,
@@ -1565,6 +4621,43 @@ const server = http.createServer(async (req, res) => {
     return;
   }
 
+  if (req.method === "GET" && url.pathname === "/api/extension/status") {
+    sendJson(req, res, 200, {
+      installed: false,
+      connected: false,
+      relayReachable: false,
+      relayPort: 0,
+      extensionPath: null,
+      chromeBuildPath: null,
+      chromePackagePath: null,
+      safariWebExtensionPath: null,
+      safariAppPath: null,
+      safariPackagePath: null,
+      releaseManifest: null,
+    });
+    return;
+  }
+
+  if (
+    (req.method === "GET" || req.method === "POST") &&
+    url.pathname === "/api/training/auto/config"
+  ) {
+    sendJson(req, res, 200, {
+      config: {
+        autoTrain: false,
+        triggerThreshold: 20,
+        triggerCooldownHours: 24,
+        backends: [],
+      },
+    });
+    return;
+  }
+
+  if (req.method === "GET" && url.pathname === "/api/training/auto/status") {
+    sendJson(req, res, 200, { serviceRegistered: false });
+    return;
+  }
+
   if (req.method === "GET" && url.pathname === "/api/lifeops/overview") {
     sendJson(req, res, 200, emptyLifeOpsOverview);
     return;
@@ -1585,6 +4678,41 @@ const server = http.createServer(async (req, res) => {
     return;
   }
 
+  // Decomposed domain-view read routes — return 200-empty so the views render
+  // their EMPTY state (not the catch-all 501 error state) in the visual smoke.
+  if (req.method === "GET" && url.pathname === "/api/lifeops/goals") {
+    sendJson(req, res, 200, { goals: [] });
+    return;
+  }
+  if (req.method === "GET" && url.pathname === "/api/lifeops/relationships") {
+    sendJson(req, res, 200, { relationships: [], entities: [] });
+    return;
+  }
+  if (req.method === "GET" && url.pathname === "/api/lifeops/money/dashboard") {
+    sendJson(req, res, 200, {
+      balanceUsd: 0,
+      sources: [],
+      recentTransactions: [],
+      recurringCharges: [],
+      spendByCategory: [],
+    });
+    return;
+  }
+  if (
+    req.method === "GET" &&
+    (url.pathname === "/api/lifeops/money/sources" ||
+      url.pathname === "/api/lifeops/money/transactions" ||
+      url.pathname === "/api/lifeops/money/recurring")
+  ) {
+    const key = url.pathname.endsWith("sources")
+      ? "sources"
+      : url.pathname.endsWith("transactions")
+        ? "transactions"
+        : "recurringCharges";
+    sendJson(req, res, 200, { [key]: [] });
+    return;
+  }
+
   if (
     req.method === "GET" &&
     url.pathname === "/api/lifeops/screen-time/summary"
@@ -1667,6 +4795,82 @@ const server = http.createServer(async (req, res) => {
     return;
   }
 
+  if (req.method === "GET" && url.pathname === "/api/apps/permissions") {
+    sendJson(req, res, 200, []);
+    return;
+  }
+
+  const appPermissionsMatch = /^\/api\/apps\/permissions\/([^/]+)$/.exec(
+    url.pathname,
+  );
+  if (appPermissionsMatch) {
+    const slug = decodeURIComponent(appPermissionsMatch[1]);
+    if (req.method === "GET") {
+      sendJson(req, res, 200, {
+        slug,
+        displayName: slug,
+        requestedNamespaces: [],
+        grantedNamespaces: [],
+      });
+      return;
+    }
+    if (req.method === "PUT") {
+      const body = (await readJsonBody(req)) || {};
+      sendJson(req, res, 200, {
+        slug,
+        displayName: slug,
+        requestedNamespaces: [],
+        grantedNamespaces: Array.isArray(body.namespaces)
+          ? body.namespaces
+          : [],
+      });
+      return;
+    }
+  }
+
+  if (url.pathname === "/api/apps/favorites") {
+    if (req.method === "GET") {
+      sendJson(req, res, 200, { favoriteApps: smokeFavoriteApps });
+      return;
+    }
+
+    if (req.method === "PUT") {
+      const body = (await readJsonBody(req)) || {};
+      const appName =
+        typeof body.appName === "string" ? body.appName.trim() : "";
+      if (appName) {
+        const next = new Set(smokeFavoriteApps);
+        if (body.isFavorite === false) {
+          next.delete(appName);
+        } else {
+          next.add(appName);
+        }
+        smokeFavoriteApps = [...next];
+      }
+      sendJson(req, res, 200, { favoriteApps: smokeFavoriteApps });
+      return;
+    }
+  }
+
+  if (req.method === "POST" && url.pathname === "/api/apps/favorites/replace") {
+    const body = (await readJsonBody(req)) || {};
+    smokeFavoriteApps = Array.isArray(body.favoriteAppNames)
+      ? body.favoriteAppNames.filter((name) => typeof name === "string")
+      : [];
+    sendJson(req, res, 200, { favoriteApps: smokeFavoriteApps });
+    return;
+  }
+
+  if (req.method === "POST" && url.pathname === "/api/apps/overlay-presence") {
+    const body = (await readJsonBody(req)) || {};
+    sendJson(req, res, 200, {
+      ok: true,
+      app: typeof body.app === "string" ? body.app : null,
+      present: body.present === true,
+    });
+    return;
+  }
+
   if (req.method === "GET" && url.pathname === "/api/skills") {
     sendJson(req, res, 200, emptySkillsResponse);
     return;
@@ -1677,6 +4881,50 @@ const server = http.createServer(async (req, res) => {
     return;
   }
 
+  if (req.method === "GET" && url.pathname === "/api/skills/curated") {
+    sendJson(req, res, 200, { skills: [] });
+    return;
+  }
+
+  if (
+    (req.method === "POST" || req.method === "DELETE") &&
+    url.pathname.startsWith("/api/skills/curated/")
+  ) {
+    sendJson(req, res, 200, { ok: true });
+    return;
+  }
+
+  if (req.method === "GET" && url.pathname === "/api/skills/catalog") {
+    sendJson(req, res, 200, {
+      total: 0,
+      page: Number(url.searchParams.get("page") ?? 1),
+      perPage: Number(url.searchParams.get("perPage") ?? 50),
+      totalPages: 0,
+      installedCount: 0,
+      skills: [],
+    });
+    return;
+  }
+
+  if (req.method === "GET" && url.pathname === "/api/skills/catalog/search") {
+    sendJson(req, res, 200, {
+      query: url.searchParams.get("q") ?? "",
+      count: 0,
+      results: [],
+    });
+    return;
+  }
+
+  if (req.method === "GET" && url.pathname.startsWith("/api/skills/catalog/")) {
+    sendJson(req, res, 404, { error: "Skill not found" });
+    return;
+  }
+
+  if (req.method === "POST" && url.pathname === "/api/skills/catalog/refresh") {
+    sendJson(req, res, 200, { ok: true, count: 0 });
+    return;
+  }
+
   if (
     req.method === "GET" &&
     url.pathname === "/api/skills/marketplace/search"
@@ -1704,7 +4952,9 @@ const server = http.createServer(async (req, res) => {
   if (
     req.method === "POST" &&
     (url.pathname === "/api/skills/marketplace/install" ||
-      url.pathname === "/api/skills/marketplace/uninstall")
+      url.pathname === "/api/skills/marketplace/uninstall" ||
+      url.pathname === "/api/skills/catalog/install" ||
+      url.pathname === "/api/skills/catalog/uninstall")
   ) {
     sendJson(req, res, 200, { ok: true });
     return;
@@ -1720,11 +4970,67 @@ const server = http.createServer(async (req, res) => {
     return;
   }
 
+  if (
+    req.method === "GET" &&
+    url.pathname === "/api/apps/screenshare/capabilities"
+  ) {
+    sendJson(req, res, 200, {
+      platform: "smoke",
+      capabilities: {
+        screenshot: { available: true, tool: "screencapture" },
+        headfulGui: { available: true, tool: "browser" },
+        keyboard: { available: false, tool: "computer-use" },
+      },
+    });
+    return;
+  }
+
+  if (
+    req.method === "GET" &&
+    url.pathname === "/api/apps/screenshare/sessions"
+  ) {
+    sendJson(req, res, 200, {
+      sessions: [
+        {
+          id: "smoke-session",
+          label: "Smoke session",
+          status: "active",
+          createdAt: SMOKE_GENERATED_AT,
+          updatedAt: SMOKE_GENERATED_AT,
+          stoppedAt: null,
+          platform: "smoke",
+          frameCount: 1,
+          inputCount: 0,
+          lastFrameAt: SMOKE_GENERATED_AT,
+          lastInputAt: null,
+        },
+      ],
+    });
+    return;
+  }
+
   if (req.method === "GET" && url.pathname === "/api/logs") {
     sendJson(req, res, 200, stubLogsResponse);
     return;
   }
 
+  if (
+    req.method === "GET" &&
+    url.pathname === "/api/__ui-smoke/unhandled-requests"
+  ) {
+    sendJson(req, res, 200, { requests: unhandledApiRequests });
+    return;
+  }
+
+  if (
+    req.method === "POST" &&
+    url.pathname === "/api/__ui-smoke/unhandled-requests/reset"
+  ) {
+    unhandledApiRequests.length = 0;
+    sendJson(req, res, 200, { ok: true });
+    return;
+  }
+
   if (req.method === "GET" && url.pathname.startsWith("/api/apps/info/")) {
     sendJson(req, res, 404, { error: "App not found" });
     return;
@@ -1758,16 +5064,87 @@ const server = http.createServer(async (req, res) => {
     return;
   }
 
+  if (req.method === "GET" && url.pathname === "/api/i18n/locale") {
+    // Mirror the real public language-suggestion route
+    // (packages/app-core/src/api/i18n-locale-routes.ts). The SPA polls this on
+    // first paint; without it the stub's catch-all 501 spams console.error.
+    sendJson(req, res, 200, { language: "en" });
+    return;
+  }
+
+  if (req.method === "POST" && url.pathname === "/api/suggestions") {
+    // Mirror the real prompt-suggestion route
+    // (packages/agent/src/api/suggestions-routes.ts). The continuous-chat
+    // overlay's resting composer strip POSTs here to upgrade its static
+    // suggestions to a model-backed set; with no model the real route returns
+    // an empty set and the overlay keeps its deterministic offline fallback.
+    // Returning the same empty set keeps the strip's static pills and avoids
+    // the catch-all 501 the diagnostics guard would otherwise flag.
+    await drainRequest(req);
+    sendJson(req, res, 200, { suggestions: [] });
+    return;
+  }
+
+  if (
+    req.method === "GET" &&
+    url.pathname === "/api/social-alpha/leaderboard"
+  ) {
+    // Mirror the social-alpha leaderboard route's zero-key behavior
+    // (plugins/plugin-social-alpha/src/routes.ts): with no recommendations
+    // recorded the real route returns an empty data array, and the view
+    // renders its wallet-required / empty state. Returning the same shape
+    // keeps the visual smoke deterministic and avoids the catch-all 501.
+    sendJson(req, res, 200, { data: [] });
+    return;
+  }
+
+  if (req.method === "POST" && url.pathname === "/api/tts/first-run/speak") {
+    // Onboarding synthesizes its scripted voice lines here and plays the bytes
+    // as audio/wav. Return decodable silence so the live stack never logs a
+    // 501; the real route (first-run-tts-route.ts) returns neural TTS audio.
+    sendBinary(req, res, 200, "audio/wav", SILENT_WAV);
+    return;
+  }
+
+  // ── Local-inference voice (drives the /chat overlay's bidirectional loop) ──
+  // The client mic capture + VAD end-of-turn are REAL (Chromium fake-audio
+  // file); these endpoints stand in for the on-device ASR/TTS models so the
+  // transcript-in / spoken-reply-out round trip stays deterministic.
+  if (
+    req.method === "GET" &&
+    url.pathname === "/api/asr/local-inference/status"
+  ) {
+    sendJson(req, res, 200, { ready: true, provider: "local-inference" });
+    return;
+  }
+
+  if (req.method === "POST" && url.pathname === "/api/asr/local-inference") {
+    // The WAV body is real captured audio; we don't transcribe it, we return a
+    // fixed phrase so the spoken turn resolves to a known message.
+    await drainRequest(req);
+    sendJson(req, res, 200, { text: SMOKE_VOICE_TRANSCRIPT });
+    return;
+  }
+
+  if (req.method === "POST" && url.pathname === "/api/tts/local-inference") {
+    // Assistant reply spoken back. Decodable silence is enough — the request
+    // itself is the bidirectional-output signal the e2e asserts on.
+    await drainRequest(req);
+    sendBinary(req, res, 200, "audio/wav", SILENT_WAV);
+    return;
+  }
+
   if (url.pathname.startsWith("/api/")) {
+    const request = recordUnhandledApiRequest(req, url);
     if (req.method === "HEAD") {
-      sendEmpty(req, res, 200);
-      return;
-    }
-    if (req.method === "GET") {
-      sendJson(req, res, 200, {});
+      sendEmpty(req, res, 501);
       return;
     }
-    sendJson(req, res, 200, { ok: true });
+    sendJson(req, res, 501, {
+      error: `Unhandled UI smoke API route: ${request.method} ${request.path}`,
+      fixture: "ui-smoke-api-stub",
+      request,
+    });
     return;
   }
 
@@ -1833,6 +5210,13 @@ async function shutdown() {
 
 for (const signal of ["SIGINT", "SIGTERM"]) {
   process.on(signal, () => {
+    if (
+      signal === "SIGTERM" &&
+      process.env.ELIZA_UI_SMOKE_STUB_IGNORE_SIGTERM === "1"
+    ) {
+      console.warn("[playwright-ui-smoke-api-stub] ignoring SIGTERM");
+      return;
+    }
     void shutdown();
   });
 }