@femtomc/mu-server 26.2.67 → 26.2.69

package/README.md

@@ -11,18 +11,19 @@ bun add @femtomc/mu-server
 ## Usage
 
 ```typescript
-import { createServer } from "@femtomc/mu-server";
+import { composeServerRuntime, createServerFromRuntime } from "@femtomc/mu-server";
 
-// Create server with default options (uses current directory as repo root)
-const server = createServer();
+const runtime = await composeServerRuntime({
+  repoRoot: "/path/to/repo"
+});
+
+// Optional: inspect startup capabilities
+console.log(runtime.capabilities);
 
-// Or specify custom repo root and port
-const server = createServer({
-  repoRoot: "/path/to/repo",
+const server = createServerFromRuntime(runtime, {
   port: 8080
 });
 
-// Start the server
 Bun.serve(server);
 ```
 

package/dist/cli.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env bun
 import { findRepoRoot } from "@femtomc/mu-core/node";
-import { createServerAsync } from "./server.js";
+import { composeServerRuntime, createServerFromRuntime } from "./server.js";
 const port = parseInt(Bun.env.PORT || "3000", 10);
 let repoRoot;
 try {
@@ -12,14 +12,15 @@ catch {
 }
 console.log(`Starting mu-server on port ${port}...`);
 console.log(`Repository root: ${repoRoot}`);
-const { serverConfig, controlPlane } = await createServerAsync({ repoRoot, port });
+const runtime = await composeServerRuntime({ repoRoot });
+const serverConfig = createServerFromRuntime(runtime, { port });
 let server;
 try {
     server = Bun.serve(serverConfig);
 }
 catch (err) {
     try {
-        await controlPlane?.stop();
+        await runtime.controlPlane?.stop();
     }
     catch {
         // Best effort cleanup. Preserve the startup error.
@@ -27,9 +28,10 @@ catch (err) {
     throw err;
 }
 console.log(`Server running at http://localhost:${port}`);
-if (controlPlane && controlPlane.activeAdapters.length > 0) {
+console.log(`Capabilities: lifecycle=[${runtime.capabilities.session_lifecycle_actions.join(",")}]`);
+if (runtime.controlPlane && runtime.controlPlane.activeAdapters.length > 0) {
     console.log("Control plane: active");
-    for (const a of controlPlane.activeAdapters) {
+    for (const a of runtime.controlPlane.activeAdapters) {
         console.log(`  ${a.name.padEnd(12)} ${a.route}`);
     }
 }
@@ -38,7 +40,7 @@ else {
     console.log(`API Status: http://localhost:${port}/api/status`);
 }
 const cleanup = async () => {
-    await controlPlane?.stop();
+    await runtime.controlPlane?.stop();
     server.stop();
     process.exit(0);
 };

package/dist/control_plane.d.ts

@@ -108,9 +108,9 @@ export type ControlPlaneSessionMutationResult = {
     message: string;
     details?: Record<string, unknown>;
 };
-export type ControlPlaneSessionMutationHooks = {
-    reload?: () => Promise<ControlPlaneSessionMutationResult>;
-    update?: () => Promise<ControlPlaneSessionMutationResult>;
+export type ControlPlaneSessionLifecycle = {
+    reload: () => Promise<ControlPlaneSessionMutationResult>;
+    update: () => Promise<ControlPlaneSessionMutationResult>;
 };
 type DetectedAdapter = {
     name: "slack";
@@ -151,7 +151,7 @@ export type BootstrapControlPlaneOpts = {
     heartbeatScheduler?: ActivityHeartbeatScheduler;
     runSupervisorSpawnProcess?: ControlPlaneRunSupervisorOpts["spawnProcess"];
     runSupervisorHeartbeatIntervalMs?: number;
-    sessionMutationHooks?: ControlPlaneSessionMutationHooks;
+    sessionLifecycle: ControlPlaneSessionLifecycle;
     generation?: ControlPlaneGenerationContext;
     telemetry?: GenerationTelemetryRecorder | null;
     telegramGenerationHooks?: TelegramGenerationSwapHooks;

package/dist/control_plane.js

@@ -767,30 +767,9 @@ export async function bootstrapControlPlane(opts) {
                         };
                     }
                     const action = record.target_type;
-                    const hook = action === "reload"
-                        ? opts.sessionMutationHooks?.reload
-                        : opts.sessionMutationHooks?.update;
-                    if (!hook) {
-                        return {
-                            terminalState: "failed",
-                            errorCode: "session_lifecycle_unavailable",
-                            trace: {
-                                cliCommandKind: action,
-                                runRootId: null,
-                            },
-                            mutatingEvents: [
-                                {
-                                    eventType: "session.lifecycle.command.failed",
-                                    payload: {
-                                        action,
-                                        reason: "hook_missing",
-                                    },
-                                },
-                            ],
-                        };
-                    }
+                    const executeLifecycleAction = action === "reload" ? opts.sessionLifecycle.reload : opts.sessionLifecycle.update;
                     try {
-                        const lifecycle = await hook();
+                        const lifecycle = await executeLifecycleAction();
                         if (!lifecycle.ok) {
                             return {
                                 terminalState: "failed",

package/dist/index.d.ts

@@ -2,7 +2,7 @@ export type { ControlPlaneActivityEvent, ControlPlaneActivityEventKind, ControlP
 export { ControlPlaneActivitySupervisor } from "./activity_supervisor.js";
 export type { MuConfig, MuConfigPatch, MuConfigPresence } from "./config.js";
 export { applyMuConfigPatch, DEFAULT_MU_CONFIG, getMuConfigPath, muConfigPresence, normalizeMuConfig, readMuConfigFile, redactMuConfigSecrets, writeMuConfigFile, } from "./config.js";
-export type { ActiveAdapter, ControlPlaneConfig, ControlPlaneHandle, ControlPlaneSessionMutationAction, ControlPlaneSessionMutationHooks, ControlPlaneSessionMutationResult, } from "./control_plane.js";
+export type { ActiveAdapter, ControlPlaneConfig, ControlPlaneHandle, ControlPlaneSessionLifecycle, ControlPlaneSessionMutationAction, ControlPlaneSessionMutationResult, } from "./control_plane.js";
 export { bootstrapControlPlane, detectAdapters } from "./control_plane.js";
 export type { CronProgramLifecycleAction, CronProgramLifecycleEvent, CronProgramOperationResult, CronProgramRegistryOpts, CronProgramSnapshot, CronProgramStatusSnapshot, CronProgramTarget, CronProgramTickEvent, CronProgramWakeMode, } from "./cron_programs.js";
 export { CronProgramRegistry } from "./cron_programs.js";
@@ -14,5 +14,5 @@ export type { HeartbeatProgramOperationResult, HeartbeatProgramRegistryOpts, Hea
 export { HeartbeatProgramRegistry } from "./heartbeat_programs.js";
 export type { ActivityHeartbeatSchedulerOpts, HeartbeatRunResult, HeartbeatTickHandler, } from "./heartbeat_scheduler.js";
 export { ActivityHeartbeatScheduler } from "./heartbeat_scheduler.js";
-export type { ServerContext, ServerOptions, ServerWithControlPlane } from "./server.js";
-export { createContext, createServer, createServerAsync } from "./server.js";
+export type { ServerContext, ServerInstanceOptions, ServerOptions, ServerRuntime, ServerRuntimeCapabilities, ServerRuntimeOptions, } from "./server.js";
+export { composeServerRuntime, createContext, createProcessSessionLifecycle, createServerFromRuntime, } from "./server.js";

package/dist/index.js

@@ -6,4 +6,4 @@ export { computeNextScheduleRunAtMs, normalizeCronSchedule } from "./cron_schedu
 export { CronTimerRegistry } from "./cron_timer.js";
 export { HeartbeatProgramRegistry } from "./heartbeat_programs.js";
 export { ActivityHeartbeatScheduler } from "./heartbeat_scheduler.js";
-export { createContext, createServer, createServerAsync } from "./server.js";
+export { composeServerRuntime, createContext, createProcessSessionLifecycle, createServerFromRuntime, } from "./server.js";

package/dist/server.d.ts

@@ -5,10 +5,20 @@ import { ForumStore } from "@femtomc/mu-forum";
 import { IssueStore } from "@femtomc/mu-issue";
 import { ControlPlaneActivitySupervisor } from "./activity_supervisor.js";
 import { type MuConfig } from "./config.js";
-import { type ControlPlaneConfig, type ControlPlaneHandle, type ControlPlaneSessionMutationHooks } from "./control_plane.js";
+import { type ControlPlaneConfig, type ControlPlaneHandle, type ControlPlaneSessionLifecycle, type ControlPlaneSessionMutationAction } from "./control_plane.js";
 import { CronProgramRegistry } from "./cron_programs.js";
 import { HeartbeatProgramRegistry } from "./heartbeat_programs.js";
 import { ActivityHeartbeatScheduler } from "./heartbeat_scheduler.js";
+type ShellCommandResult = {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+};
+type ShellCommandRunner = (command: string) => Promise<ShellCommandResult>;
+export declare function createProcessSessionLifecycle(opts: {
+    repoRoot: string;
+    runShellCommand?: ShellCommandRunner;
+}): ControlPlaneSessionLifecycle;
 type ControlPlaneReloader = (opts: {
     repoRoot: string;
     previous: ControlPlaneHandle | null;
@@ -30,8 +40,18 @@ export type ServerOptions = {
     config?: MuConfig;
     configReader?: ConfigReader;
     configWriter?: ConfigWriter;
-    sessionMutationHooks?: ControlPlaneSessionMutationHooks;
+    sessionLifecycle?: ControlPlaneSessionLifecycle;
 };
+export type ServerRuntimeOptions = {
+    repoRoot?: string;
+    controlPlane?: ControlPlaneHandle | null;
+    heartbeatScheduler?: ActivityHeartbeatScheduler;
+    generationTelemetry?: GenerationTelemetryRecorder;
+    config?: MuConfig;
+    configReader?: ConfigReader;
+    sessionLifecycle?: ControlPlaneSessionLifecycle;
+};
+export type ServerInstanceOptions = Omit<ServerOptions, "repoRoot" | "controlPlane" | "heartbeatScheduler" | "generationTelemetry" | "config" | "sessionLifecycle">;
 export type ServerContext = {
     repoRoot: string;
     issueStore: IssueStore;
@@ -40,7 +60,22 @@ export type ServerContext = {
     eventsStore: JsonlStore<EventEnvelope>;
 };
 export declare function createContext(repoRoot: string): ServerContext;
-export declare function createServer(options?: ServerOptions): {
+export type ServerRuntimeCapabilities = {
+    session_lifecycle_actions: readonly ControlPlaneSessionMutationAction[];
+    control_plane_bootstrapped: boolean;
+    control_plane_adapters: string[];
+};
+export type ServerRuntime = {
+    repoRoot: string;
+    config: MuConfig;
+    heartbeatScheduler: ActivityHeartbeatScheduler;
+    generationTelemetry: GenerationTelemetryRecorder;
+    sessionLifecycle: ControlPlaneSessionLifecycle;
+    controlPlane: ControlPlaneHandle | null;
+    capabilities: ServerRuntimeCapabilities;
+};
+export declare function composeServerRuntime(options?: ServerRuntimeOptions): Promise<ServerRuntime>;
+export declare function createServerFromRuntime(runtime: ServerRuntime, options?: ServerInstanceOptions): {
     port: number;
     fetch: (request: Request) => Promise<Response>;
     hostname: string;
@@ -49,9 +84,4 @@ export declare function createServer(options?: ServerOptions): {
     heartbeatPrograms: HeartbeatProgramRegistry;
     cronPrograms: CronProgramRegistry;
 };
-export type ServerWithControlPlane = {
-    serverConfig: ReturnType<typeof createServer>;
-    controlPlane: ControlPlaneHandle | null;
-};
-export declare function createServerAsync(options?: Omit<ServerOptions, "controlPlane">): Promise<ServerWithControlPlane>;
 export {};

package/dist/server.js

@@ -52,6 +52,143 @@ function shellQuoteArg(value) {
 function shellJoin(args) {
     return args.map(shellQuoteArg).join(" ");
 }
+function createShellCommandRunner(repoRoot) {
+    return async (command) => {
+        const proc = Bun.spawn({
+            cmd: ["bash", "-lc", command],
+            cwd: repoRoot,
+            env: Bun.env,
+            stdin: "ignore",
+            stdout: "pipe",
+            stderr: "pipe",
+        });
+        const [exitCode, stdout, stderr] = await Promise.all([
+            proc.exited,
+            proc.stdout ? new Response(proc.stdout).text() : Promise.resolve(""),
+            proc.stderr ? new Response(proc.stderr).text() : Promise.resolve(""),
+        ]);
+        return {
+            exitCode: Number.isFinite(exitCode) ? Number(exitCode) : 1,
+            stdout,
+            stderr,
+        };
+    };
+}
+export function createProcessSessionLifecycle(opts) {
+    const runShellCommand = opts.runShellCommand ?? createShellCommandRunner(opts.repoRoot);
+    let sessionMutationScheduled = null;
+    const scheduleReload = async () => {
+        if (sessionMutationScheduled) {
+            return {
+                ok: true,
+                action: sessionMutationScheduled.action,
+                message: `session ${sessionMutationScheduled.action} already scheduled`,
+                details: { scheduled_at_ms: sessionMutationScheduled.at_ms },
+            };
+        }
+        const nowMs = Date.now();
+        const restartCommand = Bun.env.MU_RESTART_COMMAND?.trim();
+        const inferredArgs = process.argv[0] === process.execPath
+            ? [process.execPath, ...process.argv.slice(1)]
+            : [process.execPath, ...process.argv];
+        const restartShellCommand = restartCommand && restartCommand.length > 0 ? restartCommand : shellJoin(inferredArgs);
+        if (!restartShellCommand.trim()) {
+            return {
+                ok: false,
+                action: "reload",
+                message: "unable to determine restart command",
+            };
+        }
+        const exitDelayMs = 1_000;
+        const launchDelayMs = exitDelayMs + 300;
+        const delayedShellCommand = `sleep ${(launchDelayMs / 1_000).toFixed(2)}; ${restartShellCommand}`;
+        let spawnedPid = null;
+        try {
+            const proc = Bun.spawn({
+                cmd: ["bash", "-lc", delayedShellCommand],
+                cwd: opts.repoRoot,
+                env: Bun.env,
+                stdin: "ignore",
+                stdout: "inherit",
+                stderr: "inherit",
+            });
+            spawnedPid = proc.pid ?? null;
+        }
+        catch (err) {
+            return {
+                ok: false,
+                action: "reload",
+                message: `failed to spawn replacement process: ${describeError(err)}`,
+            };
+        }
+        sessionMutationScheduled = { action: "reload", at_ms: nowMs };
+        setTimeout(() => {
+            process.exit(0);
+        }, exitDelayMs);
+        return {
+            ok: true,
+            action: "reload",
+            message: "reload scheduled; restarting process",
+            details: {
+                restart_command: restartShellCommand,
+                restart_launch_command: delayedShellCommand,
+                spawned_pid: spawnedPid,
+                exit_delay_ms: exitDelayMs,
+                launch_delay_ms: launchDelayMs,
+            },
+        };
+    };
+    const scheduleUpdate = async () => {
+        if (sessionMutationScheduled) {
+            return {
+                ok: true,
+                action: sessionMutationScheduled.action,
+                message: `session ${sessionMutationScheduled.action} already scheduled`,
+                details: { scheduled_at_ms: sessionMutationScheduled.at_ms },
+            };
+        }
+        const updateCommand = Bun.env.MU_UPDATE_COMMAND?.trim() || "npm install -g @femtomc/mu@latest";
+        const result = await runShellCommand(updateCommand);
+        if (result.exitCode !== 0) {
+            return {
+                ok: false,
+                action: "update",
+                message: `update command failed (exit ${result.exitCode})`,
+                details: {
+                    update_command: updateCommand,
+                    stdout: result.stdout.slice(-4_000),
+                    stderr: result.stderr.slice(-4_000),
+                },
+            };
+        }
+        const reloadResult = await scheduleReload();
+        if (!reloadResult.ok) {
+            return {
+                ok: false,
+                action: "update",
+                message: reloadResult.message,
+                details: {
+                    update_command: updateCommand,
+                    reload: reloadResult.details ?? null,
+                },
+            };
+        }
+        return {
+            ok: true,
+            action: "update",
+            message: "update applied; reload scheduled",
+            details: {
+                update_command: updateCommand,
+                reload: reloadResult.details ?? null,
+                update_stdout_tail: result.stdout.slice(-1_000),
+            },
+        };
+    };
+    return {
+        reload: scheduleReload,
+        update: scheduleUpdate,
+    };
+}
 function describeError(err) {
     if (err instanceof Error)
         return err.message;
@@ -142,7 +279,7 @@ export function createContext(repoRoot) {
     const forumStore = new ForumStore(new FsJsonlStore(paths.forumPath), { events: eventLog });
     return { repoRoot, issueStore, forumStore, eventLog, eventsStore };
 }
-export function createServer(options = {}) {
+function createServer(options = {}) {
     const repoRoot = options.repoRoot || process.cwd();
     const context = createContext(repoRoot);
     const readConfig = options.configReader ?? readMuConfigFile;
@@ -171,144 +308,7 @@ export function createServer(options = {}) {
     const autoRunHeartbeatEveryMs = Math.max(1_000, toNonNegativeInt(options.autoRunHeartbeatEveryMs, DEFAULT_AUTO_RUN_HEARTBEAT_EVERY_MS));
     const operatorWakeLastByKey = new Map();
     const autoRunHeartbeatProgramByJobId = new Map();
-    let sessionMutationScheduled = null;
-    const runShellCommand = async (command) => {
-        const proc = Bun.spawn({
-            cmd: ["bash", "-lc", command],
-            cwd: repoRoot,
-            env: Bun.env,
-            stdin: "ignore",
-            stdout: "pipe",
-            stderr: "pipe",
-        });
-        const [exitCode, stdout, stderr] = await Promise.all([
-            proc.exited,
-            proc.stdout ? new Response(proc.stdout).text() : Promise.resolve(""),
-            proc.stderr ? new Response(proc.stderr).text() : Promise.resolve(""),
-        ]);
-        return {
-            exitCode: Number.isFinite(exitCode) ? Number(exitCode) : 1,
-            stdout,
-            stderr,
-        };
-    };
-    const defaultSessionMutationHooks = {
-        reload: async () => {
-            if (sessionMutationScheduled) {
-                return {
-                    ok: true,
-                    action: sessionMutationScheduled.action,
-                    message: `session ${sessionMutationScheduled.action} already scheduled`,
-                    details: { scheduled_at_ms: sessionMutationScheduled.at_ms },
-                };
-            }
-            const nowMs = Date.now();
-            const restartCommand = Bun.env.MU_RESTART_COMMAND?.trim();
-            const inferredArgs = process.argv[0] === process.execPath
-                ? [process.execPath, ...process.argv.slice(1)]
-                : [process.execPath, ...process.argv];
-            const restartShellCommand = restartCommand && restartCommand.length > 0 ? restartCommand : shellJoin(inferredArgs);
-            if (!restartShellCommand.trim()) {
-                return {
-                    ok: false,
-                    action: "reload",
-                    message: "unable to determine restart command",
-                };
-            }
-            const exitDelayMs = 1_000;
-            const launchDelayMs = exitDelayMs + 300;
-            const delayedShellCommand = `sleep ${(launchDelayMs / 1_000).toFixed(2)}; ${restartShellCommand}`;
-            let spawnedPid = null;
-            try {
-                const proc = Bun.spawn({
-                    cmd: ["bash", "-lc", delayedShellCommand],
-                    cwd: repoRoot,
-                    env: Bun.env,
-                    stdin: "ignore",
-                    stdout: "inherit",
-                    stderr: "inherit",
-                });
-                spawnedPid = proc.pid ?? null;
-            }
-            catch (err) {
-                return {
-                    ok: false,
-                    action: "reload",
-                    message: `failed to spawn replacement process: ${describeError(err)}`,
-                };
-            }
-            sessionMutationScheduled = { action: "reload", at_ms: nowMs };
-            setTimeout(() => {
-                process.exit(0);
-            }, exitDelayMs);
-            return {
-                ok: true,
-                action: "reload",
-                message: "reload scheduled; restarting process",
-                details: {
-                    restart_command: restartShellCommand,
-                    restart_launch_command: delayedShellCommand,
-                    spawned_pid: spawnedPid,
-                    exit_delay_ms: exitDelayMs,
-                    launch_delay_ms: launchDelayMs,
-                },
-            };
-        },
-        update: async () => {
-            if (sessionMutationScheduled) {
-                return {
-                    ok: true,
-                    action: sessionMutationScheduled.action,
-                    message: `session ${sessionMutationScheduled.action} already scheduled`,
-                    details: { scheduled_at_ms: sessionMutationScheduled.at_ms },
-                };
-            }
-            const updateCommand = Bun.env.MU_UPDATE_COMMAND?.trim() || "npm install -g @femtomc/mu@latest";
-            const result = await runShellCommand(updateCommand);
-            if (result.exitCode !== 0) {
-                return {
-                    ok: false,
-                    action: "update",
-                    message: `update command failed (exit ${result.exitCode})`,
-                    details: {
-                        update_command: updateCommand,
-                        stdout: result.stdout.slice(-4_000),
-                        stderr: result.stderr.slice(-4_000),
-                    },
-                };
-            }
-            const reloadResult = await defaultSessionMutationHooks.reload?.();
-            if (!reloadResult) {
-                return {
-                    ok: false,
-                    action: "update",
-                    message: "reload hook unavailable after update",
-                };
-            }
-            if (!reloadResult.ok) {
-                return {
-                    ok: false,
-                    action: "update",
-                    message: reloadResult.message,
-                    details: {
-                        update_command: updateCommand,
-                        reload: reloadResult.details ?? null,
-                    },
-                };
-            }
-            return {
-                ok: true,
-                action: "update",
-                message: "update applied; reload scheduled",
-                details: {
-                    update_command: updateCommand,
-                    reload: reloadResult.details ?? null,
-                    update_stdout_tail: result.stdout.slice(-1_000),
-                },
-            };
-        },
-    };
-    const sessionMutationHooks = options.sessionMutationHooks ?? defaultSessionMutationHooks;
+    const sessionLifecycle = options.sessionLifecycle ?? createProcessSessionLifecycle({ repoRoot });
     const emitOperatorWake = async (opts) => {
         const dedupeKey = opts.dedupeKey.trim();
         if (!dedupeKey) {
@@ -358,7 +358,7 @@ export function createServer(options = {}) {
                 heartbeatScheduler,
                 generation,
                 telemetry: generationTelemetry,
-                sessionMutationHooks,
+                sessionLifecycle,
                 terminalEnabled: true,
             });
         });
@@ -2249,32 +2249,52 @@ export function createServer(options = {}) {
     };
     return server;
 }
-export async function createServerAsync(options = {}) {
+function computeServerRuntimeCapabilities(controlPlane) {
+    return {
+        session_lifecycle_actions: ["reload", "update"],
+        control_plane_bootstrapped: controlPlane !== null,
+        control_plane_adapters: controlPlane?.activeAdapters.map((adapter) => adapter.name) ?? [],
+    };
+}
+export async function composeServerRuntime(options = {}) {
     const repoRoot = options.repoRoot || process.cwd();
-    const config = options.config ?? (await readMuConfigFile(repoRoot));
+    const readConfig = options.configReader ?? readMuConfigFile;
+    const config = options.config ?? (await readConfig(repoRoot));
     const heartbeatScheduler = options.heartbeatScheduler ?? new ActivityHeartbeatScheduler();
     const generationTelemetry = options.generationTelemetry ?? new GenerationTelemetryRecorder();
-    const controlPlane = await bootstrapControlPlane({
+    const sessionLifecycle = options.sessionLifecycle ?? createProcessSessionLifecycle({ repoRoot });
+    const controlPlane = options.controlPlane !== undefined
+        ? options.controlPlane
+        : await bootstrapControlPlane({
+            repoRoot,
+            config: config.control_plane,
+            heartbeatScheduler,
+            generation: {
+                generation_id: "control-plane-gen-0",
+                generation_seq: 0,
+            },
+            telemetry: generationTelemetry,
+            sessionLifecycle,
+            terminalEnabled: true,
+        });
+    return {
         repoRoot,
-        config: config.control_plane,
-        heartbeatScheduler,
-        generation: {
-            generation_id: "control-plane-gen-0",
-            generation_seq: 0,
-        },
-        telemetry: generationTelemetry,
-        sessionMutationHooks: options.sessionMutationHooks,
-        terminalEnabled: true,
-    });
-    const serverConfig = createServer({
-        ...options,
-        heartbeatScheduler,
-        controlPlane,
         config,
+        heartbeatScheduler,
         generationTelemetry,
-    });
-    return {
-        serverConfig,
-        controlPlane: serverConfig.controlPlane,
+        sessionLifecycle,
+        controlPlane,
+        capabilities: computeServerRuntimeCapabilities(controlPlane),
     };
 }
+export function createServerFromRuntime(runtime, options = {}) {
+    return createServer({
+        ...options,
+        repoRoot: runtime.repoRoot,
+        config: runtime.config,
+        heartbeatScheduler: runtime.heartbeatScheduler,
+        generationTelemetry: runtime.generationTelemetry,
+        sessionLifecycle: runtime.sessionLifecycle,
+        controlPlane: runtime.controlPlane,
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@femtomc/mu-server",
-  "version": "26.2.67",
+  "version": "26.2.69",
   "description": "HTTP API server for mu status, work items, messaging setup, and web UI.",
   "keywords": [
     "mu",
@@ -31,10 +31,10 @@
     "start": "bun run dist/cli.js"
   },
   "dependencies": {
-    "@femtomc/mu-agent": "26.2.67",
-    "@femtomc/mu-control-plane": "26.2.67",
-    "@femtomc/mu-core": "26.2.67",
-    "@femtomc/mu-forum": "26.2.67",
-    "@femtomc/mu-issue": "26.2.67"
+    "@femtomc/mu-agent": "26.2.69",
+    "@femtomc/mu-control-plane": "26.2.69",
+    "@femtomc/mu-core": "26.2.69",
+    "@femtomc/mu-forum": "26.2.69",
+    "@femtomc/mu-issue": "26.2.69"
   }
 }