@femtomc/mu-server 26.2.89 → 26.2.91

package/dist/control_plane.js

@@ -1,11 +1,6 @@
 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";
-import { DurableRunQueue, queueStatesForRunStatusFilter, runSnapshotFromQueueSnapshot } from "./run_queue.js";
 import { buildMessagingOperatorRuntime, createOutboxDrainLoop } from "./control_plane_bootstrap_helpers.js";
-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";
@@ -27,17 +22,8 @@ function emptyNotifyOperatorsResult() {
         decisions: [],
     };
 }
-function normalizeIssueId(value) {
-    if (!value) {
-        return null;
-    }
-    const trimmed = value.trim();
-    if (!/^mu-[a-z0-9][a-z0-9-]*$/i.test(trimmed)) {
-        return null;
-    }
-    return trimmed.toLowerCase();
-}
 export { detectAdapters };
+const TELEGRAM_CAPTION_MAX_LEN = 1_024;
 /**
  * Telegram supports a markdown dialect that uses single markers for emphasis.
  * Normalize the most common LLM/GitHub-style markers (`**bold**`, `__italic__`, headings)
@@ -100,6 +86,287 @@ async function postTelegramMessage(botToken, payload) {
         body: JSON.stringify(payload),
     });
 }
+async function postTelegramApiJson(botToken, method, payload) {
+    return await fetch(`https://api.telegram.org/bot${botToken}/${method}`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(payload),
+    });
+}
+async function postTelegramApiMultipart(botToken, method, form) {
+    return await fetch(`https://api.telegram.org/bot${botToken}/${method}`, {
+        method: "POST",
+        body: form,
+    });
+}
+function truncateTelegramCaption(text) {
+    const normalized = text.trim();
+    if (normalized.length <= TELEGRAM_CAPTION_MAX_LEN) {
+        return normalized;
+    }
+    if (TELEGRAM_CAPTION_MAX_LEN <= 16) {
+        return normalized.slice(0, TELEGRAM_CAPTION_MAX_LEN);
+    }
+    const suffix = "…(truncated)";
+    const headLen = Math.max(0, TELEGRAM_CAPTION_MAX_LEN - suffix.length);
+    return `${normalized.slice(0, headLen)}${suffix}`;
+}
+function chooseTelegramMediaMethod(attachment) {
+    const mime = attachment.mime_type?.toLowerCase() ?? "";
+    const filename = attachment.filename?.toLowerCase() ?? "";
+    const declaredType = attachment.type.toLowerCase();
+    const isSvg = mime === "image/svg+xml" || filename.endsWith(".svg");
+    const isImageMime = mime.startsWith("image/");
+    if ((declaredType === "image" || isImageMime) && !isSvg) {
+        return "sendPhoto";
+    }
+    return "sendDocument";
+}
+function parseRetryDelayMs(res) {
+    const retryAfter = res.headers.get("retry-after");
+    if (!retryAfter) {
+        return undefined;
+    }
+    const parsed = Number.parseInt(retryAfter, 10);
+    if (!Number.isFinite(parsed) || parsed < 0) {
+        return undefined;
+    }
+    return parsed * 1000;
+}
+export async function deliverTelegramOutboxRecord(opts) {
+    const { botToken, record } = opts;
+    const fallbackMessagePayload = buildTelegramSendMessagePayload({
+        chatId: record.envelope.channel_conversation_id,
+        text: record.envelope.body,
+        richFormatting: true,
+    });
+    const firstAttachment = record.envelope.attachments?.[0] ?? null;
+    if (!firstAttachment) {
+        let res = await postTelegramMessage(botToken, fallbackMessagePayload);
+        if (!res.ok && res.status === 400 && fallbackMessagePayload.parse_mode) {
+            res = await postTelegramMessage(botToken, buildTelegramSendMessagePayload({
+                chatId: record.envelope.channel_conversation_id,
+                text: record.envelope.body,
+                richFormatting: false,
+            }));
+        }
+        if (res.ok) {
+            return { kind: "delivered" };
+        }
+        const responseBody = await res.text().catch(() => "");
+        if (res.status === 429 || res.status >= 500) {
+            return {
+                kind: "retry",
+                error: `telegram sendMessage ${res.status}: ${responseBody}`,
+                retryDelayMs: parseRetryDelayMs(res),
+            };
+        }
+        return {
+            kind: "retry",
+            error: `telegram sendMessage ${res.status}: ${responseBody}`,
+        };
+    }
+    const mediaMethod = chooseTelegramMediaMethod(firstAttachment);
+    const mediaField = mediaMethod === "sendPhoto" ? "photo" : "document";
+    const mediaReference = firstAttachment.reference.file_id ?? firstAttachment.reference.url ?? null;
+    if (!mediaReference) {
+        return { kind: "retry", error: "telegram media attachment missing reference" };
+    }
+    const mediaCaption = truncateTelegramCaption(record.envelope.body);
+    let mediaResponse;
+    if (firstAttachment.reference.file_id) {
+        mediaResponse = await postTelegramApiJson(botToken, mediaMethod, mediaMethod === "sendPhoto"
+            ? {
+                chat_id: record.envelope.channel_conversation_id,
+                photo: firstAttachment.reference.file_id,
+                caption: mediaCaption,
+            }
+            : {
+                chat_id: record.envelope.channel_conversation_id,
+                document: firstAttachment.reference.file_id,
+                caption: mediaCaption,
+            });
+    }
+    else {
+        const sourceUrl = firstAttachment.reference.url;
+        const sourceRes = await fetch(sourceUrl);
+        if (!sourceRes.ok) {
+            const sourceErr = await sourceRes.text().catch(() => "");
+            return {
+                kind: "retry",
+                error: `telegram attachment fetch ${sourceRes.status}: ${sourceErr}`,
+                retryDelayMs: sourceRes.status === 429 || sourceRes.status >= 500 ? parseRetryDelayMs(sourceRes) : undefined,
+            };
+        }
+        const body = await sourceRes.arrayBuffer();
+        const contentType = firstAttachment.mime_type ?? sourceRes.headers.get("content-type") ?? "application/octet-stream";
+        const filename = firstAttachment.filename ?? `${firstAttachment.type || "attachment"}.bin`;
+        const form = new FormData();
+        form.append("chat_id", record.envelope.channel_conversation_id);
+        if (mediaCaption.length > 0) {
+            form.append("caption", mediaCaption);
+        }
+        form.append(mediaField, new Blob([body], { type: contentType }), filename);
+        mediaResponse = await postTelegramApiMultipart(botToken, mediaMethod, form);
+    }
+    if (mediaResponse.ok) {
+        return { kind: "delivered" };
+    }
+    const mediaBody = await mediaResponse.text().catch(() => "");
+    if (mediaResponse.status === 429 || mediaResponse.status >= 500) {
+        return {
+            kind: "retry",
+            error: `telegram ${mediaMethod} ${mediaResponse.status}: ${mediaBody}`,
+            retryDelayMs: parseRetryDelayMs(mediaResponse),
+        };
+    }
+    const fallbackPlainPayload = buildTelegramSendMessagePayload({
+        chatId: record.envelope.channel_conversation_id,
+        text: record.envelope.body,
+        richFormatting: false,
+    });
+    const fallbackRes = await postTelegramMessage(botToken, fallbackPlainPayload);
+    if (fallbackRes.ok) {
+        return { kind: "delivered" };
+    }
+    const fallbackBody = await fallbackRes.text().catch(() => "");
+    if (fallbackRes.status === 429 || fallbackRes.status >= 500) {
+        return {
+            kind: "retry",
+            error: `telegram media fallback sendMessage ${fallbackRes.status}: ${fallbackBody}`,
+            retryDelayMs: parseRetryDelayMs(fallbackRes),
+        };
+    }
+    return {
+        kind: "retry",
+        error: `telegram media fallback sendMessage ${fallbackRes.status}: ${fallbackBody} (media_error=${mediaMethod} ${mediaResponse.status}: ${mediaBody})`,
+    };
+}
+async function postSlackJson(opts) {
+    const response = await fetch(`https://slack.com/api/${opts.method}`, {
+        method: "POST",
+        headers: {
+            Authorization: `Bearer ${opts.botToken}`,
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify(opts.payload),
+    });
+    const payload = (await response.json().catch(() => null));
+    return { response, payload };
+}
+export async function deliverSlackOutboxRecord(opts) {
+    const { botToken, record } = opts;
+    const attachments = record.envelope.attachments ?? [];
+    if (attachments.length === 0) {
+        const delivered = await postSlackJson({
+            botToken,
+            method: "chat.postMessage",
+            payload: {
+                channel: record.envelope.channel_conversation_id,
+                text: record.envelope.body,
+                unfurl_links: false,
+                unfurl_media: false,
+            },
+        });
+        if (delivered.response.ok && delivered.payload?.ok) {
+            return { kind: "delivered" };
+        }
+        const status = delivered.response.status;
+        const err = delivered.payload?.error ?? "unknown_error";
+        if (status === 429 || status >= 500) {
+            return {
+                kind: "retry",
+                error: `slack chat.postMessage ${status}: ${err}`,
+                retryDelayMs: parseRetryDelayMs(delivered.response),
+            };
+        }
+        return { kind: "retry", error: `slack chat.postMessage ${status}: ${err}` };
+    }
+    let firstError = null;
+    for (const [index, attachment] of attachments.entries()) {
+        const referenceUrl = attachment.reference.url;
+        if (!referenceUrl) {
+            return {
+                kind: "retry",
+                error: `slack attachment ${index + 1} missing reference.url`,
+            };
+        }
+        const source = await fetch(referenceUrl);
+        if (!source.ok) {
+            const sourceErr = await source.text().catch(() => "");
+            if (source.status === 429 || source.status >= 500) {
+                return {
+                    kind: "retry",
+                    error: `slack attachment fetch ${source.status}: ${sourceErr}`,
+                    retryDelayMs: parseRetryDelayMs(source),
+                };
+            }
+            return { kind: "retry", error: `slack attachment fetch ${source.status}: ${sourceErr}` };
+        }
+        const bytes = await source.arrayBuffer();
+        const contentType = attachment.mime_type ?? source.headers.get("content-type") ?? "application/octet-stream";
+        const filename = attachment.filename ?? `attachment-${index + 1}`;
+        const form = new FormData();
+        form.set("channels", record.envelope.channel_conversation_id);
+        form.set("filename", filename);
+        form.set("title", filename);
+        if (index === 0 && record.envelope.body.trim().length > 0) {
+            form.set("initial_comment", record.envelope.body);
+        }
+        form.set("file", new Blob([bytes], { type: contentType }), filename);
+        const uploaded = await fetch("https://slack.com/api/files.upload", {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${botToken}`,
+            },
+            body: form,
+        });
+        const uploadPayload = (await uploaded.json().catch(() => null));
+        if (!(uploaded.ok && uploadPayload?.ok)) {
+            const status = uploaded.status;
+            const err = uploadPayload?.error ?? "unknown_error";
+            if (status === 429 || status >= 500) {
+                return {
+                    kind: "retry",
+                    error: `slack files.upload ${status}: ${err}`,
+                    retryDelayMs: parseRetryDelayMs(uploaded),
+                };
+            }
+            if (!firstError) {
+                firstError = `slack files.upload ${status}: ${err}`;
+            }
+        }
+    }
+    if (firstError) {
+        const fallback = await postSlackJson({
+            botToken,
+            method: "chat.postMessage",
+            payload: {
+                channel: record.envelope.channel_conversation_id,
+                text: record.envelope.body,
+                unfurl_links: false,
+                unfurl_media: false,
+            },
+        });
+        if (fallback.response.ok && fallback.payload?.ok) {
+            return { kind: "delivered" };
+        }
+        const status = fallback.response.status;
+        const err = fallback.payload?.error ?? "unknown_error";
+        if (status === 429 || status >= 500) {
+            return {
+                kind: "retry",
+                error: `slack chat.postMessage fallback ${status}: ${err} (upload_error=${firstError})`,
+                retryDelayMs: parseRetryDelayMs(fallback.response),
+            };
+        }
+        return {
+            kind: "retry",
+            error: `slack chat.postMessage fallback ${status}: ${err} (upload_error=${firstError})`,
+        };
+    }
+    return { kind: "delivered" };
+}
 export async function bootstrapControlPlane(opts) {
     const controlPlaneConfig = opts.config ?? DEFAULT_MU_CONFIG.control_plane;
     const detected = detectAdapters(controlPlaneConfig);
@@ -124,7 +391,6 @@ export async function bootstrapControlPlane(opts) {
     const paths = getControlPlanePaths(opts.repoRoot);
     const runtime = new ControlPlaneRuntime({ repoRoot: opts.repoRoot });
     let pipeline = null;
-    let runSupervisor = null;
     let outboxDrainLoop = null;
     let wakeDeliveryObserver = opts.wakeDeliveryObserver ?? null;
     const outboundDeliveryChannels = new Set();
@@ -143,29 +409,6 @@ export async function bootstrapControlPlane(opts) {
         });
         await outbox.load();
         let scheduleOutboxDrainRef = null;
-        const runQueue = new DurableRunQueue({ repoRoot: opts.repoRoot });
-        const interRootQueuePolicy = normalizeInterRootQueuePolicy(opts.interRootQueuePolicy ?? DEFAULT_INTER_ROOT_QUEUE_POLICY);
-        const runQueueCoordinator = new ControlPlaneRunQueueCoordinator({
-            runQueue,
-            interRootQueuePolicy,
-            getRunSupervisor: () => runSupervisor,
-        });
-        runSupervisor = new ControlPlaneRunSupervisor({
-            repoRoot: opts.repoRoot,
-            spawnProcess: opts.runSupervisorSpawnProcess,
-            onEvent: async (event) => {
-                await runQueueCoordinator.onRunEvent(event);
-                const outboxRecord = await enqueueRunEventOutbox({
-                    outbox,
-                    event,
-                    nowMs: Math.trunc(Date.now()),
-                });
-                if (outboxRecord) {
-                    scheduleOutboxDrainRef?.();
-                }
-            },
-        });
-        await runQueueCoordinator.scheduleReconcile("bootstrap");
         pipeline = new ControlPlaneCommandPipeline({
             runtime,
             operator,
@@ -177,7 +420,6 @@ export async function bootstrapControlPlane(opts) {
                             errorCode: "cli_validation_failed",
                             trace: {
                                 cliCommandKind: record.target_type,
-                                runRootId: null,
                             },
                             mutatingEvents: [
                                 {
@@ -201,7 +443,6 @@ export async function bootstrapControlPlane(opts) {
                                 errorCode: "session_lifecycle_failed",
                                 trace: {
                                     cliCommandKind: action,
-                                    runRootId: null,
                                 },
                                 mutatingEvents: [
                                     {
@@ -225,7 +466,6 @@ export async function bootstrapControlPlane(opts) {
                             },
                             trace: {
                                 cliCommandKind: action,
-                                runRootId: null,
                             },
                             mutatingEvents: [
                                 {
@@ -245,7 +485,6 @@ export async function bootstrapControlPlane(opts) {
                             errorCode: err instanceof Error && err.message ? err.message : "session_lifecycle_failed",
                             trace: {
                                 cliCommandKind: action,
-                                runRootId: null,
                             },
                             mutatingEvents: [
                                 {
@@ -259,96 +498,6 @@ export async function bootstrapControlPlane(opts) {
                         };
                     }
                 }
-                if (record.target_type === "run start" || record.target_type === "run resume") {
-                    try {
-                        const launched = await runQueueCoordinator.launchQueuedRunFromCommand(record);
-                        return {
-                            terminalState: "completed",
-                            result: {
-                                ok: true,
-                                async_run: true,
-                                run_job_id: launched.job_id,
-                                run_root_id: launched.root_issue_id,
-                                run_status: launched.status,
-                                run_mode: launched.mode,
-                                run_source: launched.source,
-                            },
-                            trace: {
-                                cliCommandKind: launched.mode,
-                                runRootId: launched.root_issue_id,
-                            },
-                            mutatingEvents: [
-                                {
-                                    eventType: "run.supervisor.start",
-                                    payload: {
-                                        run_job_id: launched.job_id,
-                                        run_mode: launched.mode,
-                                        run_root_id: launched.root_issue_id,
-                                        run_source: launched.source,
-                                        queue_id: launched.queue_id ?? null,
-                                        queue_state: launched.queue_state ?? null,
-                                    },
-                                },
-                            ],
-                        };
-                    }
-                    catch (err) {
-                        return {
-                            terminalState: "failed",
-                            errorCode: err instanceof Error && err.message ? err.message : "run_queue_start_failed",
-                            trace: {
-                                cliCommandKind: record.target_type.replaceAll(" ", "_"),
-                                runRootId: record.target_id,
-                            },
-                        };
-                    }
-                }
-                if (record.target_type === "run interrupt") {
-                    const result = await runQueueCoordinator.interruptQueuedRun({
-                        rootIssueId: record.target_id,
-                    });
-                    if (!result.ok) {
-                        return {
-                            terminalState: "failed",
-                            errorCode: result.reason ?? "run_interrupt_failed",
-                            trace: {
-                                cliCommandKind: "run_interrupt",
-                                runRootId: result.run?.root_issue_id ?? record.target_id,
-                            },
-                            mutatingEvents: [
-                                {
-                                    eventType: "run.supervisor.interrupt.failed",
-                                    payload: {
-                                        reason: result.reason,
-                                        target: record.target_id,
-                                    },
-                                },
-                            ],
-                        };
-                    }
-                    return {
-                        terminalState: "completed",
-                        result: {
-                            ok: true,
-                            async_run: true,
-                            interrupted: true,
-                            run: result.run,
-                        },
-                        trace: {
-                            cliCommandKind: "run_interrupt",
-                            runRootId: result.run?.root_issue_id ?? record.target_id,
-                        },
-                        mutatingEvents: [
-                            {
-                                eventType: "run.supervisor.interrupt",
-                                payload: {
-                                    target: record.target_id,
-                                    run: result.run,
-                                },
-                            },
-                        ],
-                    };
-                }
                 return null;
             },
         });
@@ -366,6 +515,7 @@ export async function bootstrapControlPlane(opts) {
         await telegramManager.initialize();
         for (const adapter of createStaticAdaptersFromDetected({
             detected,
+            config: controlPlaneConfig,
             pipeline,
             outbox,
         })) {
@@ -416,6 +566,19 @@ export async function bootstrapControlPlane(opts) {
             isActive: () => telegramManager.hasActiveGeneration(),
         });
         const deliveryRouter = new OutboundDeliveryRouter([
+            {
+                channel: "slack",
+                deliver: async (record) => {
+                    const slackBotToken = controlPlaneConfig.adapters.slack.bot_token;
+                    if (!slackBotToken) {
+                        return { kind: "retry", error: "slack bot token not configured in mu workspace config" };
+                    }
+                    return await deliverSlackOutboxRecord({
+                        botToken: slackBotToken,
+                        record,
+                    });
+                },
+            },
             {
                 channel: "telegram",
                 deliver: async (record) => {
@@ -423,44 +586,15 @@ export async function bootstrapControlPlane(opts) {
                     if (!telegramBotToken) {
                         return { kind: "retry", error: "telegram bot token not configured in mu workspace config" };
                     }
-                    const richPayload = buildTelegramSendMessagePayload({
-                        chatId: record.envelope.channel_conversation_id,
-                        text: record.envelope.body,
-                        richFormatting: true,
+                    return await deliverTelegramOutboxRecord({
+                        botToken: telegramBotToken,
+                        record,
                     });
-                    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);
-        }
+        outboundDeliveryChannels.add("slack");
+        outboundDeliveryChannels.add("telegram");
         const notifyOperators = async (notifyOpts) => {
             if (!pipeline) {
                 return emptyNotifyOperatorsResult();
@@ -491,6 +625,7 @@ export async function bootstrapControlPlane(opts) {
                 sourceTsMs: wakeSourceTsMs,
             };
             const nowMs = Math.trunc(Date.now());
+            const slackBotToken = controlPlaneConfig.adapters.slack.bot_token;
             const telegramBotToken = telegramManager.activeBotToken();
             const bindings = pipeline.identities
                 .listBindings({ includeInactive: false })
@@ -505,6 +640,7 @@ export async function bootstrapControlPlane(opts) {
                 const capability = resolveWakeFanoutCapability({
                     binding,
                     isChannelDeliverySupported: (channel) => outboundDeliveryChannels.has(channel),
+                    slackBotToken,
                     telegramBotToken,
                 });
                 if (!capability.ok) {
@@ -624,76 +760,6 @@ export async function bootstrapControlPlane(opts) {
                 }
                 return result;
             },
-            async listRuns(opts = {}) {
-                const limit = Math.max(1, Math.min(500, Math.trunc(opts.limit ?? 100)));
-                const fallbackStatusFilter = queueStatesForRunStatusFilter(opts.status);
-                if (Array.isArray(fallbackStatusFilter) && fallbackStatusFilter.length === 0) {
-                    return [];
-                }
-                const queued = await runQueue.listRunSnapshots({
-                    status: opts.status,
-                    limit,
-                    runtimeByJobId: runQueueCoordinator.runtimeSnapshotsByJobId(),
-                });
-                const seen = new Set(queued.map((run) => run.job_id));
-                const fallbackRuns = runSupervisor?.list({ limit: 500 }) ?? [];
-                for (const run of fallbackRuns) {
-                    if (seen.has(run.job_id)) {
-                        continue;
-                    }
-                    if (fallbackStatusFilter && fallbackStatusFilter.length > 0) {
-                        const mapped = run.status === "completed"
-                            ? "done"
-                            : run.status === "failed"
-                                ? "failed"
-                                : run.status === "cancelled"
-                                    ? "cancelled"
-                                    : "active";
-                        if (!fallbackStatusFilter.includes(mapped)) {
-                            continue;
-                        }
-                    }
-                    queued.push(run);
-                    seen.add(run.job_id);
-                }
-                return queued.slice(0, limit);
-            },
-            async getRun(idOrRoot) {
-                const queued = await runQueue.get(idOrRoot);
-                if (queued) {
-                    const runtime = queued.job_id ? (runSupervisor?.get(queued.job_id) ?? null) : null;
-                    return runSnapshotFromQueueSnapshot(queued, runtime);
-                }
-                return runSupervisor?.get(idOrRoot) ?? null;
-            },
-            async startRun(startOpts) {
-                return await runQueueCoordinator.launchQueuedRun({
-                    mode: "run_start",
-                    prompt: startOpts.prompt,
-                    maxSteps: startOpts.maxSteps,
-                    source: "api",
-                    dedupeKey: `api:run_start:${crypto.randomUUID()}`,
-                });
-            },
-            async resumeRun(resumeOpts) {
-                const rootIssueId = normalizeIssueId(resumeOpts.rootIssueId);
-                if (!rootIssueId) {
-                    throw new Error("run_resume_invalid_root_issue_id");
-                }
-                return await runQueueCoordinator.launchQueuedRun({
-                    mode: "run_resume",
-                    rootIssueId,
-                    maxSteps: resumeOpts.maxSteps,
-                    source: "api",
-                    dedupeKey: `api:run_resume:${rootIssueId}:${crypto.randomUUID()}`,
-                });
-            },
-            async interruptRun(interruptOpts) {
-                return await runQueueCoordinator.interruptQueuedRun(interruptOpts);
-            },
-            async traceRun(traceOpts) {
-                return (await runSupervisor?.trace(traceOpts.idOrRoot, { limit: traceOpts.limit })) ?? null;
-            },
             async submitTerminalCommand(terminalOpts) {
                 if (!pipeline) {
                     throw new Error("control_plane_pipeline_unavailable");
@@ -702,7 +768,6 @@ export async function bootstrapControlPlane(opts) {
             },
             async stop() {
                 wakeDeliveryObserver = null;
-                runQueueCoordinator.stop();
                 if (outboxDrainLoop) {
                     outboxDrainLoop.stop();
                     outboxDrainLoop = null;
@@ -715,7 +780,6 @@ export async function bootstrapControlPlane(opts) {
                         // Best effort adapter cleanup.
                     }
                 }
-                await runSupervisor?.stop();
                 try {
                     await pipeline?.stop();
                 }
@@ -739,12 +803,6 @@ export async function bootstrapControlPlane(opts) {
                 // Best effort cleanup.
             }
         }
-        try {
-            await runSupervisor?.stop();
-        }
-        catch {
-            // Best effort cleanup.
-        }
         try {
             await pipeline?.stop();
         }

package/dist/control_plane_adapter_registry.d.ts

@@ -14,6 +14,7 @@ export type DetectedAdapter = DetectedStaticAdapter | DetectedTelegramAdapter;
 export declare function detectAdapters(config: ControlPlaneConfig): DetectedAdapter[];
 export declare function createStaticAdaptersFromDetected(opts: {
     detected: readonly DetectedAdapter[];
+    config: ControlPlaneConfig;
     pipeline: ControlPlaneCommandPipeline;
     outbox: ControlPlaneOutbox;
 }): ControlPlaneAdapter[];