stageflow 0.35.0 → 0.39.0

package/dist/server/bootstrap.js

@@ -2,7 +2,7 @@ import path from "node:path";
 import { getAgentDir } from "@earendil-works/pi-coding-agent";
 import { createA2aHost } from "../a2a/server.js";
 import { A2aStore } from "../a2a/store.js";
-import { createRunStoreWithConnection } from "../runstore/createStore.js";
+import { createRunStoreWithConnection, sqliteConnectionFromStore } from "../runstore/createStore.js";
 import { resolveA2aConfigPath } from "../a2a/configDiscovery.js";
 import { ensureProjectRootsFromEnv } from "../project/ensureProjectRootsFromEnv.js";
 import { ensureGlobalHome, globalStageflowHome } from "../project/globalHome.js";
@@ -20,6 +20,8 @@ import { GithubPollSource, githubPollIntervalMsFromEnv, } from "../runtime/githu
 import { EmailSource } from "../runtime/emailSource.js";
 import { emailHostFor, releaseEmailHost } from "../email/host.js";
 import { EmailTriggers } from "../email/triggers.js";
+import { startChannelService } from "../channels/service.js";
+import { memoryHostFor } from "../memory/host.js";
 import { fireTrigger } from "../runtime/triggerRunner.js";
 import { createRunChangeBus, getRunChangeBusFromWrappedStore, isRunStoreWrapped, wrapRunStoreWithChangeBus, } from "../runtime/runChangeBus.js";
 import { createMcpHttpHandler, resolveMcpStateless, } from "../mcp/server.js";
@@ -29,16 +31,9 @@ import { readCursorApiKey } from "../agent/cursorProvider.js";
 import { applyPendingRestoreAtBoot, } from "../runstore/restore.js";
 import { assertTmpdirUsable } from "../runstore/assertTmpdir.js";
 import { logger as rootLogger } from "../logging/logger.js";
+import { getModelCatalog } from "../models/catalog.js";
+import { createAgentHostContext } from "../agents/hostContext.js";
 export const DEFAULT_GC_INTERVAL_MS = 60 * 60 * 1000;
-function sqliteConnectionFromStore(store) {
-    const connection = store.connection;
-    if (connection !== undefined &&
-        connection !== null &&
-        typeof connection.prepare === "function") {
-        return connection;
-    }
-    return undefined;
-}
 /** Parse `STAGEFLOW_GC_INTERVAL_MS`; default 1h; `0` disables. */
 export function gcIntervalMsFromEnv(env = process.env) {
     const raw = env.STAGEFLOW_GC_INTERVAL_MS;
@@ -331,10 +326,35 @@ export async function bootstrapStageflowHost(options) {
         await Promise.all([stopAccountEmail(), emailSource.stop(), scheduleSource.stop(), githubPollSource.stop()]);
         throw error;
     }
+    const channels = startChannelService(cwd);
     const stopEmailSource = () => {
+        void agentHost?.stop();
         void emailSource.stop();
         void stopAccountEmail();
+        void channels.stop();
     };
+    // Resolve the connected-provider list and the default model once at boot so sync callers see the catalog's answer.
+    void getModelCatalog(cwd)
+        .defaultModel()
+        .catch((error) => bootLog.warn("models.catalog_warm_failed", String(error)));
+    const agentHost = sqliteConnection !== undefined
+        ? createAgentHostContext({
+            cwd,
+            agentDir,
+            connection: sqliteConnection,
+            channels,
+            ...(options.agentConversationBackend ? { backend: options.agentConversationBackend } : {}),
+            listenOnChannels: process.env.STAGEFLOW_AGENT_CHANNEL_LISTENERS !== "0",
+            toolkitDeps: {
+                manager,
+                store,
+                agentDir,
+                projectRoot: rootDir,
+                ...(options.providerAuthContext ? { providerAuthContext: options.providerAuthContext } : {}),
+                ...(providerBoot !== undefined ? { providerBoot } : {}),
+            },
+        })
+        : undefined;
     const mcpStateless = resolveMcpStateless({
         mcpStateless: options.mcpStateless,
     });
@@ -346,6 +366,13 @@ export async function bootstrapStageflowHost(options) {
         runChangeBus,
         providerAuthContext: options.providerAuthContext,
         projectRoot: rootDir,
+        ...(agentHost
+            ? {
+                agentService: agentHost.service,
+                agentChat: agentHost.chat,
+                agentConversationBackend: agentHost.backend,
+            }
+            : {}),
         ...(providerBoot !== undefined ? { providerBoot } : {}),
     }, { mcpStateless });
     return {
@@ -374,7 +401,10 @@ export async function bootstrapStageflowHost(options) {
         stopGithubPollSource,
         stopEmailSource,
         email: { ...emailHost, triggers: emailTriggers, stop: stopAccountEmail },
+        channels,
+        memories: memoryHostFor(),
         storeFilesystem,
         workspaceCatalog,
+        ...(agentHost ? { agentHost } : {}),
     };
 }

package/dist/server/channelRoutes.d.ts

@@ -0,0 +1,9 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { ChannelService } from "../channels/service.js";
+type Json = (res: ServerResponse, status: number, body: unknown) => void;
+/**
+ * Listing, live checks and edits. Request bodies carry secret values on the way in only; nothing
+ * the API returns contains one, and failures answer with a code, never the request or its values.
+ */
+export declare function handleChannelRoutes(req: IncomingMessage, method: string, pathname: string, service: ChannelService, res: ServerResponse, json: Json): Promise<boolean>;
+export {};

package/dist/server/channelRoutes.js

@@ -0,0 +1,88 @@
+import { ChannelError } from "../channels/errors.js";
+import { channelErrorStatus } from "../channels/errorInfo.js";
+const MAX_BODY_BYTES = 65536;
+async function readBody(req) {
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of req) {
+        const buffer = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
+        size += buffer.length;
+        if (size > MAX_BODY_BYTES)
+            throw new ChannelError("CHANNEL_RESOURCE_LIMIT");
+        chunks.push(buffer);
+    }
+    if (chunks.length === 0)
+        return {};
+    try {
+        return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+    }
+    catch {
+        throw new ChannelError("CHANNEL_INVALID_INPUT");
+    }
+}
+/**
+ * Listing, live checks and edits. Request bodies carry secret values on the way in only; nothing
+ * the API returns contains one, and failures answer with a code, never the request or its values.
+ */
+export async function handleChannelRoutes(req, method, pathname, service, res, json) {
+    const idMatch = pathname.match(/^\/api\/connections\/([^/]+)(?:\/(check|validate-target))?$/);
+    const isCollection = pathname === "/api/connections";
+    const isTest = pathname === "/api/connections/test";
+    const isMeta = pathname === "/api/connections/meta";
+    if (!isCollection && !isTest && !isMeta && !idMatch)
+        return false;
+    try {
+        if (isMeta && method === "GET") {
+            json(res, 200, service.meta());
+            return true;
+        }
+        if (isCollection && method === "GET") {
+            json(res, 200, service.list());
+            return true;
+        }
+        if (isCollection && method === "POST") {
+            json(res, 201, await service.create(await readBody(req)));
+            return true;
+        }
+        if (isTest && method === "POST") {
+            json(res, 200, await service.test(await readBody(req)));
+            return true;
+        }
+        if (idMatch) {
+            let id;
+            try {
+                id = decodeURIComponent(idMatch[1]);
+            }
+            catch {
+                throw new ChannelError("CHANNEL_INVALID_INPUT");
+            }
+            if (idMatch[2] === "check" && method === "POST") {
+                const health = await service.checkNow(id);
+                if (health)
+                    json(res, 200, health);
+                else
+                    json(res, 404, { code: "CHANNEL_NOT_FOUND" });
+                return true;
+            }
+            if (idMatch[2] === "validate-target" && method === "POST") {
+                json(res, 200, service.validateTarget(id, await readBody(req)));
+                return true;
+            }
+            if (!idMatch[2] && method === "PATCH") {
+                json(res, 200, await service.update(id, await readBody(req)));
+                return true;
+            }
+            if (!idMatch[2] && method === "DELETE") {
+                await service.remove(id);
+                json(res, 200, { removed: true });
+                return true;
+            }
+        }
+    }
+    catch (error) {
+        const code = error instanceof ChannelError ? error.code : "CHANNEL_STORAGE_FAILED";
+        json(res, channelErrorStatus(code), { code });
+        return true;
+    }
+    return false;
+}

package/dist/server/controlToken.js

@@ -175,6 +175,10 @@ export class BindRefusedError extends Error {
 function isTriggerWebhookRoute(method, pathname) {
     return method === "POST" && /^\/api\/triggers\/[^/]+\/webhook$/.test(pathname);
 }
+/** Agent webhooks authenticate by the provider's own signature against the connection's inbound secret. */
+function isAgentInboundRoute(method, pathname) {
+    return method === "POST" && /^\/api\/agent-inbound\/[^/]+$/.test(pathname);
+}
 /**
  * Live view routes authenticate themselves: the ticket route checks the bearer
  * scope for the requested mode, and the browser's event stream and input posts
@@ -190,6 +194,10 @@ export function requiredScopeFor(method, pathname) {
         return null;
     if (isTriggerWebhookRoute(method, pathname))
         return null;
+    if (isAgentInboundRoute(method, pathname))
+        return null;
+    if (pathname.startsWith("/api/public/chat/"))
+        return null;
     if (isLiveViewRoute(pathname))
         return null;
     if (pathname === "/api/backup" || pathname.startsWith("/api/backup/")) {

package/dist/server/http.d.ts

@@ -3,11 +3,13 @@ import { type ProviderAuthContext } from "../agent/providerAuth.js";
 import { type LiveViewRoutesOptions } from "./liveViewRoutes.js";
 import { WorkshopChatSessionRegistry } from "../workshop/chatTurn.js";
 import { type AgentPort } from "../operatorAgent/index.js";
-import type { RunStoreKind } from "../runstore/createStore.js";
+import { type RunStoreKind } from "../runstore/createStore.js";
 import type { RunStore } from "../runstore/port.js";
 import type { RunManager } from "../runtime/runManager.js";
 import type { RunChangeBus } from "../runtime/runChangeBus.js";
 import type { StageBrowserSupport } from "../browser/browserHost.js";
+import { type AgentHostContext } from "../agents/hostContext.js";
+import type { ConversationBackend } from "../agents/sessions.js";
 import { EmailTriggers } from "../email/triggers.js";
 import { type AllowedHosts } from "./allowedHosts.js";
 import { type ControlTokens } from "./controlToken.js";
@@ -33,6 +35,7 @@ export type UiServerOptions = {
     browser?: StageBrowserSupport;
     /** Optional AgentPort. Workshop is the caller today; tests inject a fake. */
     workshopOperatorHost?: AgentPort;
+    agentConversationBackend?: ConversationBackend;
 };
 export declare function defaultUiDistDir(): string;
 export type OperatorRouteDeps = {
@@ -61,6 +64,10 @@ export type OperatorRouteDeps = {
      * Defaults to a registry owned by this route surface.
      */
     workshopChatRegistry?: WorkshopChatSessionRegistry;
+    /** Injectable agent chat backend (tests). Defaults to Pi conversation host. */
+    agentConversationBackend?: ConversationBackend;
+    /** Shared with MCP when set by bootstrap. */
+    agentHost?: AgentHostContext;
 };
 /**
  * The full operator-console route surface: REST API (runs, stages,

package/dist/server/http.js

@@ -1,3 +1,4 @@
+import { OVERVIEW_RANGES, buildOverview, isOverviewRange, overviewWindowMs, } from "../runstore/overviewSummary.js";
 import { readFile, access } from "node:fs/promises";
 import { createReadStream, statSync } from "node:fs";
 import path from "node:path";
@@ -25,7 +26,7 @@ import { createWorkshopBuild, focusUnboundWorkshopBuild, getWorkshopBuild, listW
 import { resolveAgentPort } from "../operatorAgent/index.js";
 import { listPipelinesForContext } from "../config/browseCatalog.js";
 import { catalogContextFromStageflow } from "../config/resolveCatalogContext.js";
-import { listModelsMultiProject, listPipelinesMultiProject, listTasksMultiProject, } from "../config/multiProjectCatalog.js";
+import { listPipelinesMultiProject, listTasksMultiProject, } from "../config/multiProjectCatalog.js";
 import { catalogPathErrorBody, CatalogPathError, resolveCatalogRelativePath, resolveCatalogStartInput, resolveDefaultWriteRoot, resolveWritableCatalogRoot, } from "../config/catalogRelativePath.js";
 import { listExtensions } from "../config/listExtensions.js";
 import { listSkills } from "../config/listSkills.js";
@@ -36,6 +37,7 @@ import { validateCatalog } from "../config/validateCatalog.js";
 import { artifactMediaType, classifyArtifactContent, readRunArtifact, readRunArtifactBytes, } from "../mcp/readArtifact.js";
 import { getRunDiff, listCheckoutChanges, readCheckoutFileBytes, } from "../mcp/checkoutTools.js";
 import { readStageVerificationHistory } from "../runstore/verificationHistory.js";
+import { sqliteConnectionFromStore } from "../runstore/createStore.js";
 import { BackupError, createBackup, resolveBackupDownloadPath, } from "../runstore/backup.js";
 import { RestoreError, resolveBackupNameForRestore, stageRestoreForBoot, } from "../runstore/restore.js";
 import { iterateExportNdjson } from "../cli/exportAllCommand.js";
@@ -51,6 +53,15 @@ import { isTaskFile } from "../runtime/taskInput.js";
 import { findTokenShapedField, tokenRejectedPayload, } from "../runtime/startPayload.js";
 import { parseAskOperatorAnswer } from "../tools/askOperator.js";
 import { handleEmailRoutes } from "./emailRoutes.js";
+import { defaultAgentProjectRoot } from "../agents/projectRoot.js";
+import { PublicWebChat } from "../agents/webChat/publicChat.js";
+import { buildModelsResponse } from "../models/response.js";
+import { createAgentHostContext } from "../agents/hostContext.js";
+import { AgentScheduleSource, agentScheduleTickIntervalMsFromEnv, } from "../agents/scheduleSource.js";
+import { handleAgentAuthorRoutes } from "./agentAuthorRoutes.js";
+import { handleAgentRoutes } from "./agentRoutes.js";
+import { handleChannelRoutes } from "./channelRoutes.js";
+import { handleMemoryRoutes } from "./memoryRoutes.js";
 import { bootstrapStageflowHost, } from "./bootstrap.js";
 import { assertAllowedHttpAccess, isTrustedLocalHttpRequest, resolveAllowedHosts, } from "./allowedHosts.js";
 import { enforceBearerAuth, loadControlTokens, requiredScopeFor, } from "./controlToken.js";
@@ -172,13 +183,38 @@ export function defaultUiDistDir() {
     return path.resolve(here, "../ui");
 }
 export function createOperatorRoutes(deps) {
-    const { manager, store, cwd, agentDir, rootDir, providerAuthContext, uiDistDir, workshopOperatorHost, } = deps;
-    const workshopChatRegistry = deps.workshopChatRegistry ??
-        new WorkshopChatSessionRegistry(workshopOperatorHost ??
-            resolveAgentPort({
+    const { manager, store, cwd, agentDir, rootDir, providerAuthContext, uiDistDir, workshopOperatorHost, agentConversationBackend, agentHost: injectedHost, } = deps;
+    const agentConnection = injectedHost ? undefined : sqliteConnectionFromStore(store);
+    const agentHost = injectedHost ??
+        (agentConnection
+            ? createAgentHostContext({
                 cwd,
-                projectRoot: cwd,
-            }));
+                agentDir,
+                connection: agentConnection,
+                ...(agentConversationBackend ? { backend: agentConversationBackend } : {}),
+            })
+            : undefined);
+    const agentScheduleSource = agentHost
+        ? new AgentScheduleSource({
+            service: agentHost.service,
+            projectRoot: defaultAgentProjectRoot(cwd),
+            intervalMs: agentScheduleTickIntervalMsFromEnv(),
+        })
+        : undefined;
+    void agentScheduleSource?.start(async (event) => {
+        await agentHost.chat.send({
+            projectRoot: defaultAgentProjectRoot(cwd),
+            agentId: event.agentId,
+            text: event.message,
+            source: "schedule",
+        });
+    });
+    const operatorHost = workshopOperatorHost ??
+        resolveAgentPort({
+            cwd,
+            projectRoot: cwd,
+        });
+    const workshopChatRegistry = deps.workshopChatRegistry ?? new WorkshopChatSessionRegistry(operatorHost);
     const workshopSessionStoreRoot = () => resolveWorkshopSessionStoreRoot();
     const workshopBuildStoreRoot = () => resolveWorkshopBuildStoreRoot();
     const allowedHosts = deps.allowedHosts ?? resolveAllowedHosts();
@@ -214,6 +250,108 @@ export function createOperatorRoutes(deps) {
             try {
                 if (await liveView.handle(req, res))
                     return true;
+                if (pathname === "/api/agent-author/chat" || pathname === "/api/agent-author/undo") {
+                    if (await handleAgentAuthorRoutes(req, method, pathname, cwd, operatorHost, res, json))
+                        return true;
+                }
+                if (PublicWebChat.owns(pathname)) {
+                    if (!agentHost) {
+                        json(res, 503, { code: "web_chat.unavailable" });
+                        return true;
+                    }
+                    return await agentHost.publicChat.handle(req, res, method, pathname);
+                }
+                if (method === "GET" && uiDistDir !== undefined && /^\/chat\/[^/]+$/.test(pathname)) {
+                    const page = path.join(uiDistDir, "chat.html");
+                    try {
+                        const html = await readFile(page);
+                        res.writeHead(200, { "Content-Type": "text/html; charset=utf-8", "Cache-Control": "no-store", "Referrer-Policy": "no-referrer", "X-Robots-Tag": "noindex" });
+                        res.end(html);
+                        return true;
+                    }
+                    catch {
+                        json(res, 404, { error: "Chat page not built. Run npm run ui:build." });
+                        return true;
+                    }
+                }
+                const agentInbound = method === "POST" ? pathname.match(/^\/api\/agent-inbound\/([^/]+)$/) : null;
+                if (agentInbound) {
+                    if (!agentHost) {
+                        json(res, 503, { code: "agent.store_unavailable" });
+                        return true;
+                    }
+                    const declared = Number(req.headers["content-length"] ?? 0);
+                    if (declared > 1024 * 1024) {
+                        json(res, 413, {});
+                        return true;
+                    }
+                    const chunks = [];
+                    let received = 0;
+                    for await (const chunk of req) {
+                        const buffer = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
+                        received += buffer.length;
+                        if (received > 1024 * 1024) {
+                            json(res, 413, {});
+                            req.destroy();
+                            return true;
+                        }
+                        chunks.push(buffer);
+                    }
+                    const raw = Buffer.concat(chunks);
+                    const headers = {};
+                    for (const [name, value] of Object.entries(req.headers))
+                        headers[name] = Array.isArray(value) ? value[0] : value;
+                    const outcome = await agentHost.inbound.handle(decodeURIComponent(agentInbound[1]), headers, raw.toString("utf8"));
+                    json(res, outcome.status, outcome.body ?? {});
+                    return true;
+                }
+                if (pathname === "/api/agents" || pathname.startsWith("/api/agents/")) {
+                    if (!agentHost) {
+                        json(res, 503, { code: "agent.store_unavailable" });
+                        return true;
+                    }
+                    // Default: the Host's own project. An explicit project_root must be a known catalog root
+                    // (writable for writes); its filesystem path, not its wire id, is where agents/ lives.
+                    let agentProjectRoot = defaultAgentProjectRoot(cwd);
+                    const requestedRoot = url.searchParams.get("project_root");
+                    if (requestedRoot !== null && path.resolve(requestedRoot) !== path.resolve(agentProjectRoot)) {
+                        try {
+                            const resolved = method === "GET"
+                                ? await resolveCatalogStartInput({ store, bootCwd: cwd }, requestedRoot)
+                                : await resolveWritableCatalogRoot({ store, bootCwd: cwd }, requestedRoot);
+                            agentProjectRoot = resolved.wireRoot.path;
+                        }
+                        catch (err) {
+                            if (err instanceof CatalogPathError) {
+                                json(res, 400, catalogPathErrorBody(err));
+                                return true;
+                            }
+                            throw err;
+                        }
+                    }
+                    if (await handleAgentRoutes(req, method, pathname, agentHost, agentProjectRoot, res, json))
+                        return true;
+                }
+                if (pathname === "/api/memories" || pathname.startsWith("/api/memories/")) {
+                    if (!assertAllowedHttpAccess({ entries: [] }, req, res, { requireOrigin: method !== "GET" }))
+                        return true;
+                    if (!boot.memories) {
+                        json(res, 503, { code: "memory.unavailable" });
+                        return true;
+                    }
+                    if (await handleMemoryRoutes(req, method, pathname, boot.memories, res, json))
+                        return true;
+                }
+                if (pathname === "/api/connections" || pathname.startsWith("/api/connections/")) {
+                    if (!assertAllowedHttpAccess({ entries: [] }, req, res, { requireOrigin: method !== "GET" }))
+                        return true;
+                    if (!boot.channels) {
+                        json(res, 503, { code: "CHANNEL_CONNECTION_FAILED" });
+                        return true;
+                    }
+                    if (await handleChannelRoutes(req, method, pathname, boot.channels, res, json))
+                        return true;
+                }
                 if (pathname.startsWith("/api/email/")) {
                     if (!assertAllowedHttpAccess({ entries: [] }, req, res, { requireOrigin: ["POST", "PATCH", "DELETE"].includes(method) }))
                         return true;
@@ -2719,27 +2857,26 @@ export function createOperatorRoutes(deps) {
                     });
                     return true;
                 }
-                if (method === "GET" && pathname === "/api/models") {
+                if ((method === "GET" && pathname === "/api/models") || (method === "POST" && pathname === "/api/models/refresh")) {
+                    if (method === "POST" && !assertAllowedHttpAccess({ entries: [] }, req, res, { requireOrigin: true }))
+                        return true;
                     const filter = url.searchParams.get("project_root") ?? undefined;
-                    const result = await listModelsMultiProject({
+                    const { response, used } = await buildModelsResponse({
                         store,
-                        bootCwd: cwd,
+                        cwd,
                         projectRootFilter: filter,
+                        refresh: method === "POST",
                     });
-                    if (result.root_errors.some((e) => e.code === "unknown_project_root") &&
-                        result.items.length === 0) {
+                    if (used.root_errors.some((e) => e.code === "unknown_project_root") &&
+                        used.items.length === 0) {
                         json(res, 400, {
-                            error: result.root_errors[0].message,
+                            error: used.root_errors[0].message,
                             code: "unknown_project_root",
-                            root_errors: result.root_errors,
+                            root_errors: used.root_errors,
                         });
                         return true;
                     }
-                    json(res, 200, {
-                        models: result.models,
-                        entries: result.items,
-                        root_errors: result.root_errors,
-                    });
+                    json(res, 200, response);
                     return true;
                 }
                 if (await handleProviderRoutes(req, res, {
@@ -2752,6 +2889,7 @@ export function createOperatorRoutes(deps) {
                 }
                 if (await handleProjectMcpRoutes(req, res, {
                     projectRoot: rootDir,
+                    readJsonBody,
                     json,
                 })) {
                     return true;
@@ -2865,6 +3003,20 @@ export function createOperatorRoutes(deps) {
                     await handleApiHealth(req, res, boot);
                     return true;
                 }
+                if (method === "GET" && pathname === "/api/overview") {
+                    const rangeParam = url.searchParams.get("range") ?? "7d";
+                    if (!isOverviewRange(rangeParam)) {
+                        json(res, 400, {
+                            error: `range must be one of ${OVERVIEW_RANGES.join(", ")}`,
+                            code: "invalid_range",
+                        });
+                        return true;
+                    }
+                    const now = new Date();
+                    const since = new Date(now.getTime() - 2 * overviewWindowMs(rangeParam)).toISOString();
+                    json(res, 200, buildOverview(await store.listRunOverviewRows(since), rangeParam, now));
+                    return true;
+                }
                 if (method === "GET" && pathname === "/api/settings") {
                     const health = manager.getHealth();
                     const credential = getCredentialSourceSettings(cwd);
@@ -2961,7 +3113,14 @@ export function createOperatorRoutes(deps) {
             }
         }
     };
-    return Object.assign(handler, { dispose: () => liveView.dispose() });
+    return Object.assign(handler, {
+        dispose: async () => {
+            await agentScheduleSource?.stop();
+            if (!injectedHost)
+                await agentHost?.stop();
+            await liveView.dispose();
+        },
+    });
 }
 export async function startUiServer(options) {
     const host = options.host ?? "127.0.0.1";
@@ -2991,6 +3150,10 @@ export async function startUiServer(options) {
             ...(options.workshopOperatorHost
                 ? { workshopOperatorHost: options.workshopOperatorHost }
                 : {}),
+            ...(boot.agentHost ? { agentHost: boot.agentHost } : {}),
+            ...(options.agentConversationBackend
+                ? { agentConversationBackend: options.agentConversationBackend }
+                : {}),
         });
     const envelope = await createHttpHost({
         boot,

package/dist/server/mcpHost.js

@@ -27,6 +27,7 @@ export async function startMcpServer(options) {
             allowedHosts,
             controlTokens,
             getShutdown: () => shutdown,
+            ...(boot.agentHost ? { agentHost: boot.agentHost } : {}),
         });
     const envelope = await createHttpHost({
         boot,

package/dist/server/memoryRoutes.d.ts

@@ -0,0 +1,5 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import { type MemoryHost } from "../memory/host.js";
+type Json = (res: ServerResponse, status: number, body: unknown) => void;
+export declare function handleMemoryRoutes(req: IncomingMessage, method: string, pathname: string, host: MemoryHost, res: ServerResponse, json: Json): Promise<boolean>;
+export {};