@femtomc/mu-server 26.2.73 → 26.2.75

package/dist/control_plane.js

@@ -1,4 +1,4 @@
-import { ControlPlaneCommandPipeline, ControlPlaneOutbox, ControlPlaneRuntime, DiscordControlPlaneAdapter, getControlPlanePaths, SlackControlPlaneAdapter, TelegramControlPlaneAdapterSpec, } from "@femtomc/mu-control-plane";
+import { ControlPlaneCommandPipeline, ControlPlaneOutbox, ControlPlaneRuntime, getControlPlanePaths, TelegramControlPlaneAdapterSpec, } from "@femtomc/mu-control-plane";
 import { DEFAULT_MU_CONFIG } from "./config.js";
 import { DEFAULT_INTER_ROOT_QUEUE_POLICY, normalizeInterRootQueuePolicy, } from "./control_plane_contract.js";
 import { ControlPlaneRunSupervisor, } from "./run_supervisor.js";
@@ -7,6 +7,8 @@ import { buildMessagingOperatorRuntime, createOutboxDrainLoop } from "./control_
 import { ControlPlaneRunQueueCoordinator } from "./control_plane_run_queue_coordinator.js";
 import { enqueueRunEventOutbox } from "./control_plane_run_outbox.js";
 import { buildWakeOutboundEnvelope, resolveWakeFanoutCapability, wakeDeliveryMetadataFromOutboxRecord, wakeDispatchReasonCode, wakeFanoutDedupeKey, } from "./control_plane_wake_delivery.js";
+import { createStaticAdaptersFromDetected, detectAdapters, } from "./control_plane_adapter_registry.js";
+import { OutboundDeliveryRouter } from "./outbound_delivery_router.js";
 import { TelegramAdapterGenerationManager } from "./control_plane_telegram_generation.js";
 function generationTags(generation, component) {
     return {
@@ -35,27 +37,7 @@ function normalizeIssueId(value) {
     }
     return trimmed.toLowerCase();
 }
-export function detectAdapters(config) {
-    const adapters = [];
-    const slackSecret = config.adapters.slack.signing_secret;
-    if (slackSecret) {
-        adapters.push({ name: "slack", signingSecret: slackSecret });
-    }
-    const discordSecret = config.adapters.discord.signing_secret;
-    if (discordSecret) {
-        adapters.push({ name: "discord", signingSecret: discordSecret });
-    }
-    const telegramSecret = config.adapters.telegram.webhook_secret;
-    if (telegramSecret) {
-        adapters.push({
-            name: "telegram",
-            webhookSecret: telegramSecret,
-            botToken: config.adapters.telegram.bot_token,
-            botUsername: config.adapters.telegram.bot_username,
-        });
-    }
-    return adapters;
-}
+export { detectAdapters };
 /**
  * Telegram supports a markdown dialect that uses single markers for emphasis.
  * Normalize the most common LLM/GitHub-style markers (`**bold**`, `__italic__`, headings)
@@ -145,7 +127,7 @@ export async function bootstrapControlPlane(opts) {
     let runSupervisor = null;
     let outboxDrainLoop = null;
     let wakeDeliveryObserver = opts.wakeDeliveryObserver ?? null;
-    const outboundDeliveryChannels = new Set(["telegram"]);
+    const outboundDeliveryChannels = new Set();
     const adapterMap = new Map();
     try {
         await runtime.start();
@@ -170,8 +152,6 @@ export async function bootstrapControlPlane(opts) {
         });
         runSupervisor = new ControlPlaneRunSupervisor({
             repoRoot: opts.repoRoot,
-            heartbeatScheduler: opts.heartbeatScheduler,
-            heartbeatIntervalMs: opts.runSupervisorHeartbeatIntervalMs,
             spawnProcess: opts.runSupervisorSpawnProcess,
             onEvent: async (event) => {
                 await runQueueCoordinator.onRunEvent(event);
@@ -384,21 +364,11 @@ export async function bootstrapControlPlane(opts) {
             hooks: opts.telegramGenerationHooks,
         });
         await telegramManager.initialize();
-        for (const d of detected) {
-            if (d.name === "telegram") {
-                continue;
-            }
-            const adapter = d.name === "slack"
-                ? new SlackControlPlaneAdapter({
-                    pipeline,
-                    outbox,
-                    signingSecret: d.signingSecret,
-                })
-                : new DiscordControlPlaneAdapter({
-                    pipeline,
-                    outbox,
-                    signingSecret: d.signingSecret,
-                });
+        for (const adapter of createStaticAdaptersFromDetected({
+            detected,
+            pipeline,
+            outbox,
+        })) {
             const route = adapter.spec.route;
             if (adapterMap.has(route)) {
                 throw new Error(`duplicate control-plane webhook route: ${route}`);
@@ -445,6 +415,52 @@ export async function bootstrapControlPlane(opts) {
             },
             isActive: () => telegramManager.hasActiveGeneration(),
         });
+        const deliveryRouter = new OutboundDeliveryRouter([
+            {
+                channel: "telegram",
+                deliver: async (record) => {
+                    const telegramBotToken = telegramManager.activeBotToken();
+                    if (!telegramBotToken) {
+                        return { kind: "retry", error: "telegram bot token not configured in .mu/config.json" };
+                    }
+                    const richPayload = buildTelegramSendMessagePayload({
+                        chatId: record.envelope.channel_conversation_id,
+                        text: record.envelope.body,
+                        richFormatting: true,
+                    });
+                    let res = await postTelegramMessage(telegramBotToken, richPayload);
+                    // Fallback: if Telegram rejects markdown entities, retry as plain text.
+                    if (!res.ok && res.status === 400 && richPayload.parse_mode) {
+                        const plainPayload = buildTelegramSendMessagePayload({
+                            chatId: record.envelope.channel_conversation_id,
+                            text: record.envelope.body,
+                            richFormatting: false,
+                        });
+                        res = await postTelegramMessage(telegramBotToken, plainPayload);
+                    }
+                    if (res.ok) {
+                        return { kind: "delivered" };
+                    }
+                    const responseBody = await res.text().catch(() => "");
+                    if (res.status === 429 || res.status >= 500) {
+                        const retryAfter = res.headers.get("retry-after");
+                        const retryDelayMs = retryAfter ? Number.parseInt(retryAfter, 10) * 1000 : undefined;
+                        return {
+                            kind: "retry",
+                            error: `telegram sendMessage ${res.status}: ${responseBody}`,
+                            retryDelayMs: retryDelayMs && Number.isFinite(retryDelayMs) ? retryDelayMs : undefined,
+                        };
+                    }
+                    return {
+                        kind: "retry",
+                        error: `telegram sendMessage ${res.status}: ${responseBody}`,
+                    };
+                },
+            },
+        ]);
+        for (const channel of deliveryRouter.supportedChannels()) {
+            outboundDeliveryChannels.add(channel);
+        }
         const notifyOperators = async (notifyOpts) => {
             if (!pipeline) {
                 return emptyNotifyOperatorsResult();
@@ -544,46 +560,7 @@ export async function bootstrapControlPlane(opts) {
             return result;
         };
         const deliver = async (record) => {
-            const { envelope } = record;
-            if (envelope.channel === "telegram") {
-                const telegramBotToken = telegramManager.activeBotToken();
-                if (!telegramBotToken) {
-                    return { kind: "retry", error: "telegram bot token not configured in .mu/config.json" };
-                }
-                const richPayload = buildTelegramSendMessagePayload({
-                    chatId: envelope.channel_conversation_id,
-                    text: envelope.body,
-                    richFormatting: true,
-                });
-                let res = await postTelegramMessage(telegramBotToken, richPayload);
-                // Fallback: if Telegram rejects markdown entities, retry as plain text.
-                if (!res.ok && res.status === 400 && richPayload.parse_mode) {
-                    const plainPayload = buildTelegramSendMessagePayload({
-                        chatId: envelope.channel_conversation_id,
-                        text: envelope.body,
-                        richFormatting: false,
-                    });
-                    res = await postTelegramMessage(telegramBotToken, plainPayload);
-                }
-                if (res.ok) {
-                    return { kind: "delivered" };
-                }
-                const responseBody = await res.text().catch(() => "");
-                if (res.status === 429 || res.status >= 500) {
-                    const retryAfter = res.headers.get("retry-after");
-                    const retryDelayMs = retryAfter ? Number.parseInt(retryAfter, 10) * 1000 : undefined;
-                    return {
-                        kind: "retry",
-                        error: `telegram sendMessage ${res.status}: ${responseBody}`,
-                        retryDelayMs: retryDelayMs && Number.isFinite(retryDelayMs) ? retryDelayMs : undefined,
-                    };
-                }
-                return {
-                    kind: "retry",
-                    error: `telegram sendMessage ${res.status}: ${responseBody}`,
-                };
-            }
-            return undefined;
+            return await deliveryRouter.deliver(record);
         };
         const outboxDrain = createOutboxDrainLoop({
             outbox,
@@ -714,9 +691,6 @@ export async function bootstrapControlPlane(opts) {
             async interruptRun(interruptOpts) {
                 return await runQueueCoordinator.interruptQueuedRun(interruptOpts);
             },
-            async heartbeatRun(heartbeatOpts) {
-                return await runQueueCoordinator.heartbeatQueuedRun(heartbeatOpts);
-            },
             async traceRun(traceOpts) {
                 return (await runSupervisor?.trace(traceOpts.idOrRoot, { limit: traceOpts.limit })) ?? null;
             },

package/dist/control_plane_adapter_registry.d.ts

@@ -0,0 +1,19 @@
+import { type ControlPlaneAdapter, type ControlPlaneCommandPipeline, type ControlPlaneOutbox } from "@femtomc/mu-control-plane";
+import type { ControlPlaneConfig } from "./control_plane_contract.js";
+export type DetectedStaticAdapter = {
+    name: "slack" | "discord" | "neovim";
+    secret: string;
+};
+export type DetectedTelegramAdapter = {
+    name: "telegram";
+    webhookSecret: string;
+    botToken: string | null;
+    botUsername: string | null;
+};
+export type DetectedAdapter = DetectedStaticAdapter | DetectedTelegramAdapter;
+export declare function detectAdapters(config: ControlPlaneConfig): DetectedAdapter[];
+export declare function createStaticAdaptersFromDetected(opts: {
+    detected: readonly DetectedAdapter[];
+    pipeline: ControlPlaneCommandPipeline;
+    outbox: ControlPlaneOutbox;
+}): ControlPlaneAdapter[];

package/dist/control_plane_adapter_registry.js

@@ -0,0 +1,74 @@
+import { DiscordControlPlaneAdapter, NeovimControlPlaneAdapter, SlackControlPlaneAdapter, } from "@femtomc/mu-control-plane";
+const STATIC_ADAPTER_MODULES = [
+    {
+        name: "slack",
+        detectSecret: (config) => config.adapters.slack.signing_secret,
+        create: (opts) => new SlackControlPlaneAdapter({
+            pipeline: opts.pipeline,
+            outbox: opts.outbox,
+            signingSecret: opts.secret,
+        }),
+    },
+    {
+        name: "discord",
+        detectSecret: (config) => config.adapters.discord.signing_secret,
+        create: (opts) => new DiscordControlPlaneAdapter({
+            pipeline: opts.pipeline,
+            outbox: opts.outbox,
+            signingSecret: opts.secret,
+        }),
+    },
+    {
+        name: "neovim",
+        detectSecret: (config) => config.adapters.neovim.shared_secret,
+        create: (opts) => new NeovimControlPlaneAdapter({
+            pipeline: opts.pipeline,
+            sharedSecret: opts.secret,
+        }),
+    },
+];
+const STATIC_ADAPTER_BY_NAME = new Map(STATIC_ADAPTER_MODULES.map((module) => [module.name, module]));
+function isStaticAdapter(adapter) {
+    return adapter.name !== "telegram";
+}
+export function detectAdapters(config) {
+    const detected = [];
+    for (const module of STATIC_ADAPTER_MODULES) {
+        const secret = module.detectSecret(config);
+        if (!secret) {
+            continue;
+        }
+        detected.push({
+            name: module.name,
+            secret,
+        });
+    }
+    const telegramSecret = config.adapters.telegram.webhook_secret;
+    if (telegramSecret) {
+        detected.push({
+            name: "telegram",
+            webhookSecret: telegramSecret,
+            botToken: config.adapters.telegram.bot_token,
+            botUsername: config.adapters.telegram.bot_username,
+        });
+    }
+    return detected;
+}
+export function createStaticAdaptersFromDetected(opts) {
+    const adapters = [];
+    for (const detected of opts.detected) {
+        if (!isStaticAdapter(detected)) {
+            continue;
+        }
+        const module = STATIC_ADAPTER_BY_NAME.get(detected.name);
+        if (!module) {
+            throw new Error(`missing static adapter module: ${detected.name}`);
+        }
+        adapters.push(module.create({
+            pipeline: opts.pipeline,
+            outbox: opts.outbox,
+            secret: detected.secret,
+        }));
+    }
+    return adapters;
+}

package/dist/control_plane_contract.d.ts

@@ -1,5 +1,5 @@
 import type { Channel, CommandPipelineResult, ReloadableGenerationIdentity } from "@femtomc/mu-control-plane";
-import type { ControlPlaneRunHeartbeatResult, ControlPlaneRunInterruptResult, ControlPlaneRunSnapshot, ControlPlaneRunTrace } from "./run_supervisor.js";
+import type { ControlPlaneRunInterruptResult, ControlPlaneRunSnapshot, ControlPlaneRunTrace } from "./run_supervisor.js";
 import type { MuConfig } from "./config.js";
 /**
  * Boundary contracts for server/control-plane composition.
@@ -154,12 +154,6 @@ export type ControlPlaneHandle = {
         jobId?: string | null;
         rootIssueId?: string | null;
     }): Promise<ControlPlaneRunInterruptResult>;
-    heartbeatRun?(opts: {
-        jobId?: string | null;
-        rootIssueId?: string | null;
-        reason?: string | null;
-        wakeMode?: string | null;
-    }): Promise<ControlPlaneRunHeartbeatResult>;
     traceRun?(opts: {
         idOrRoot: string;
         limit?: number;

package/dist/control_plane_run_queue_coordinator.d.ts

@@ -1,7 +1,7 @@
 import type { CommandRecord } from "@femtomc/mu-control-plane";
 import type { InterRootQueuePolicy } from "./control_plane_contract.js";
 import { DurableRunQueue } from "./run_queue.js";
-import type { ControlPlaneRunEvent, ControlPlaneRunHeartbeatResult, ControlPlaneRunInterruptResult, ControlPlaneRunSnapshot, ControlPlaneRunSupervisor } from "./run_supervisor.js";
+import type { ControlPlaneRunEvent, ControlPlaneRunInterruptResult, ControlPlaneRunSnapshot, ControlPlaneRunSupervisor } from "./run_supervisor.js";
 export type QueueLaunchOpts = {
     mode: "run_start" | "run_resume";
     prompt?: string;
@@ -37,12 +37,6 @@ export declare class ControlPlaneRunQueueCoordinator {
         jobId?: string | null;
         rootIssueId?: string | null;
     }): Promise<ControlPlaneRunInterruptResult>;
-    heartbeatQueuedRun(opts: {
-        jobId?: string | null;
-        rootIssueId?: string | null;
-        reason?: string | null;
-        wakeMode?: string | null;
-    }): Promise<ControlPlaneRunHeartbeatResult>;
     onRunEvent(event: ControlPlaneRunEvent): Promise<void>;
     stop(): void;
 }

package/dist/control_plane_run_queue_coordinator.js

@@ -20,12 +20,6 @@ function normalizeIssueId(value) {
     }
     return trimmed.toLowerCase();
 }
-function isTerminalQueueState(state) {
-    return state === "done" || state === "failed" || state === "cancelled";
-}
-function isInFlightQueueState(state) {
-    return state === "active" || state === "waiting_review" || state === "refining";
-}
 /**
  * Queue/reconcile adapter for control-plane run lifecycle operations.
  *
@@ -251,60 +245,8 @@ export class ControlPlaneRunQueueCoordinator {
             run: runSnapshotFromQueueSnapshot(queued),
         };
     }
-    async heartbeatQueuedRun(opts) {
-        const runSupervisor = this.#getRunSupervisor();
-        const result = runSupervisor?.heartbeat(opts) ?? { ok: false, reason: "not_found", run: null };
-        let syncedQueue = null;
-        if (result.run) {
-            syncedQueue = await this.#runQueue
-                .applyRunSnapshot({
-                run: result.run,
-                operationId: `heartbeat-sync:${result.run.job_id}:${result.run.updated_at_ms}`,
-                createIfMissing: true,
-            })
-                .catch(() => {
-                // Best effort only.
-                return null;
-            });
-        }
-        if (result.ok || result.reason === "missing_target") {
-            if (syncedQueue && isTerminalQueueState(syncedQueue.state)) {
-                await this.scheduleReconcile(`heartbeat-terminal:${syncedQueue.queue_id}`);
-            }
-            return result;
-        }
-        const target = opts.jobId?.trim() || opts.rootIssueId?.trim() || "";
-        if (!target) {
-            return result;
-        }
-        const queued = await this.#runQueue.get(target);
-        if (!queued) {
-            return result;
-        }
-        if (result.reason === "not_found" && queued.job_id && isInFlightQueueState(queued.state)) {
-            const failed = await this.#runQueue.transition({
-                queueId: queued.queue_id,
-                toState: "failed",
-                operationId: `heartbeat-fallback:not-found:${queued.queue_id}`,
-            });
-            await this.scheduleReconcile(`heartbeat-fallback:not-found:${queued.queue_id}`);
-            return {
-                ok: false,
-                reason: "not_running",
-                run: runSnapshotFromQueueSnapshot(failed),
-            };
-        }
-        if ((syncedQueue && isTerminalQueueState(syncedQueue.state)) || (result.reason === "not_running" && isInFlightQueueState(queued.state))) {
-            await this.scheduleReconcile(`heartbeat-wake:${queued.queue_id}:${result.reason ?? "unknown"}`);
-        }
-        return {
-            ok: false,
-            reason: "not_running",
-            run: runSnapshotFromQueueSnapshot(queued),
-        };
-    }
     async onRunEvent(event) {
-        const queueEventSnapshot = await this.#runQueue
+        await this.#runQueue
             .applyRunSnapshot({
             run: event.run,
             operationId: `run-event:${event.seq}:${event.kind}`,
@@ -314,9 +256,6 @@ export class ControlPlaneRunQueueCoordinator {
             // Best effort queue reconciliation from runtime events.
             return null;
         });
-        if (event.kind === "run_heartbeat" && queueEventSnapshot && isInFlightQueueState(queueEventSnapshot.state)) {
-            await this.scheduleReconcile(`event-wake:run_heartbeat:${queueEventSnapshot.queue_id}:${event.seq}`);
-        }
         if (event.kind === "run_completed" || event.kind === "run_failed" || event.kind === "run_cancelled") {
             await this.scheduleReconcile(`terminal:${event.kind}:${event.run.job_id}`);
         }

package/dist/control_plane_telegram_generation.js

@@ -10,6 +10,7 @@ function controlPlaneNonTelegramFingerprint(config) {
         adapters: {
             slack: config.adapters.slack,
             discord: config.adapters.discord,
+            neovim: config.adapters.neovim,
         },
         operator: config.operator,
     });

package/dist/control_plane_wake_delivery.js

@@ -15,6 +15,7 @@ function normalizeChannel(value) {
         case "slack":
         case "discord":
         case "telegram":
+        case "neovim":
         case "terminal":
             return value;
         default:

package/dist/cron_programs.d.ts

@@ -2,15 +2,6 @@ import type { JsonlStore } from "@femtomc/mu-core";
 import { type CronProgramSchedule } from "./cron_schedule.js";
 import { CronTimerRegistry } from "./cron_timer.js";
 import type { ActivityHeartbeatScheduler } from "./heartbeat_scheduler.js";
-export type CronProgramTarget = {
-    kind: "run";
-    job_id: string | null;
-    root_issue_id: string | null;
-} | {
-    kind: "activity";
-    activity_id: string;
-};
-export type CronProgramWakeMode = "immediate" | "next_heartbeat";
 export type CronProgramSnapshot = {
     v: 1;
     program_id: string;
@@ -18,14 +9,12 @@ export type CronProgramSnapshot = {
     enabled: boolean;
     schedule: CronProgramSchedule;
     reason: string;
-    wake_mode: CronProgramWakeMode;
-    target: CronProgramTarget;
     metadata: Record<string, unknown>;
     created_at_ms: number;
     updated_at_ms: number;
     next_run_at_ms: number | null;
     last_triggered_at_ms: number | null;
-    last_result: "ok" | "not_found" | "not_running" | "failed" | null;
+    last_result: "ok" | "coalesced" | "failed" | null;
     last_error: string | null;
 };
 export type CronProgramLifecycleAction = "created" | "updated" | "deleted" | "scheduled" | "disabled" | "oneshot_completed";
@@ -40,13 +29,13 @@ export type CronProgramTickEvent = {
     ts_ms: number;
     program_id: string;
     message: string;
-    status: "ok" | "not_found" | "not_running" | "failed";
+    status: "ok" | "coalesced" | "failed";
     reason: string | null;
     program: CronProgramSnapshot;
 };
 export type CronProgramOperationResult = {
     ok: boolean;
-    reason: "not_found" | "missing_target" | "invalid_target" | "invalid_schedule" | "not_running" | "failed" | null;
+    reason: "not_found" | "missing_target" | "invalid_schedule" | "not_running" | "failed" | null;
     program: CronProgramSnapshot | null;
 };
 export type CronProgramStatusSnapshot = {
@@ -58,28 +47,30 @@ export type CronProgramStatusSnapshot = {
         due_at_ms: number;
     }>;
 };
+export type CronProgramDispatchResult = {
+    status: "ok";
+    reason?: string | null;
+} | {
+    status: "coalesced";
+    reason?: string | null;
+} | {
+    status: "failed";
+    reason: string;
+};
 export type CronProgramRegistryOpts = {
     repoRoot: string;
     heartbeatScheduler: ActivityHeartbeatScheduler;
     nowMs?: () => number;
     timer?: CronTimerRegistry;
     store?: JsonlStore<CronProgramSnapshot>;
-    runHeartbeat: (opts: {
-        jobId?: string | null;
-        rootIssueId?: string | null;
-        reason?: string | null;
-        wakeMode?: CronProgramWakeMode;
-    }) => Promise<{
-        ok: boolean;
-        reason: "not_found" | "not_running" | "missing_target" | null;
-    }>;
-    activityHeartbeat: (opts: {
-        activityId?: string | null;
-        reason?: string | null;
-    }) => Promise<{
-        ok: boolean;
-        reason: "not_found" | "not_running" | "missing_target" | null;
-    }>;
+    dispatchWake: (opts: {
+        programId: string;
+        title: string;
+        reason: string;
+        metadata: Record<string, unknown>;
+        triggeredAtMs: number;
+        schedule: CronProgramSchedule;
+    }) => Promise<CronProgramDispatchResult>;
     onTickEvent?: (event: CronProgramTickEvent) => void | Promise<void>;
     onLifecycleEvent?: (event: CronProgramLifecycleEvent) => void | Promise<void>;
 };
@@ -88,7 +79,6 @@ export declare class CronProgramRegistry {
     constructor(opts: CronProgramRegistryOpts);
     list(opts?: {
         enabled?: boolean;
-        targetKind?: "run" | "activity";
         scheduleKind?: "at" | "every" | "cron";
         limit?: number;
     }): Promise<CronProgramSnapshot[]>;
@@ -96,10 +86,8 @@ export declare class CronProgramRegistry {
     get(programId: string): Promise<CronProgramSnapshot | null>;
     create(opts: {
         title: string;
-        target: CronProgramTarget;
         schedule: unknown;
         reason?: string;
-        wakeMode?: CronProgramWakeMode;
         enabled?: boolean;
         metadata?: Record<string, unknown>;
     }): Promise<CronProgramSnapshot>;
@@ -107,9 +95,7 @@ export declare class CronProgramRegistry {
         programId: string;
         title?: string;
         reason?: string;
-        wakeMode?: CronProgramWakeMode;
         enabled?: boolean;
-        target?: CronProgramTarget;
         schedule?: unknown;
         metadata?: Record<string, unknown>;
     }): Promise<CronProgramOperationResult>;