@femtomc/mu-server 26.2.95 → 26.2.97

package/README.md

@@ -91,6 +91,9 @@ Use `mu store paths --pretty` to resolve `<store>` for the active repo/workspace
         "memory_index": {
           "enabled": true,
           "every_ms": 300000
+        },
+        "operator": {
+          "timeout_ms": 600000
         }
       }
     }
@@ -153,6 +156,7 @@ mu control status --pretty
 - Discord: `control_plane.adapters.discord.signing_secret`
 - Telegram: `control_plane.adapters.telegram.webhook_secret`, `bot_token`, `bot_username`
 - Neovim: `control_plane.adapters.neovim.shared_secret`
+- Optional operator tuning: `control_plane.operator.timeout_ms` (max wall-time per messaging turn, default `600000`).
 
 3) Reload live control-plane runtime:
 
@@ -189,6 +193,13 @@ When validating attachment support end-to-end, use this sequence:
 Operational fallback expectations:
 
 - If media upload fails, Telegram delivery falls back to text `sendMessage`.
+- Telegram text delivery chunks long messages into deterministic in-order `sendMessage` calls to stay below API size limits.
+- When outbound metadata includes `telegram_reply_to_message_id`, Telegram delivery anchors replies to the originating chat message.
+- Invalid/non-integer `telegram_reply_to_message_id` metadata is ignored so delivery degrades gracefully to non-anchored sends.
+- Awaiting-confirmation envelopes include Telegram inline `Confirm`/`Cancel` callback buttons when interaction metadata provides confirmation actions.
+- Telegram callback payloads are contract-limited to `confirm:<command_id>` and `cancel:<command_id>`; unsupported payloads are explicitly rejected.
+- Callback buttons keep parity with command fallback: `/mu confirm <id>` and `/mu cancel <id>` remain valid.
+- Group/supergroup Telegram freeform text is deterministic no-op with guidance; explicit `/mu ...` commands stay actionable.
 - If Slack/Telegram bot token is missing, channel capability reason codes should report `*_bot_token_missing` and outbound delivery retries rather than hard-crashing runtime.
 
 ## Running the Server

package/dist/config.d.ts

@@ -23,6 +23,7 @@ export type MuConfig = {
             provider: string | null;
             model: string | null;
             thinking: string | null;
+            timeout_ms: number;
         };
         memory_index: {
             enabled: boolean;
@@ -54,6 +55,7 @@ export type MuConfigPatch = {
             provider?: string | null;
             model?: string | null;
             thinking?: string | null;
+            timeout_ms?: number;
         };
         memory_index?: {
             enabled?: boolean;
@@ -85,6 +87,7 @@ export type MuConfigPresence = {
             provider: boolean;
             model: boolean;
             thinking: boolean;
+            timeout_ms: number;
         };
         memory_index: {
             enabled: boolean;

package/dist/config.js

@@ -26,6 +26,7 @@ export const DEFAULT_MU_CONFIG = {
             provider: null,
             model: null,
             thinking: null,
+            timeout_ms: 600_000,
         },
         memory_index: {
             enabled: true,
@@ -129,6 +130,9 @@ export function normalizeMuConfig(input) {
         if ("thinking" in operator) {
             next.control_plane.operator.thinking = normalizeNullableString(operator.thinking);
         }
+        if ("timeout_ms" in operator) {
+            next.control_plane.operator.timeout_ms = normalizeInteger(operator.timeout_ms, next.control_plane.operator.timeout_ms, { min: 1_000, max: 7_200_000 });
+        }
     }
     const memoryIndex = asRecord(controlPlane.memory_index);
     if (memoryIndex) {
@@ -214,6 +218,9 @@ function normalizeMuConfigPatch(input) {
         if ("thinking" in operator) {
             patch.control_plane.operator.thinking = normalizeNullableString(operator.thinking);
         }
+        if ("timeout_ms" in operator) {
+            patch.control_plane.operator.timeout_ms = normalizeInteger(operator.timeout_ms, DEFAULT_MU_CONFIG.control_plane.operator.timeout_ms, { min: 1_000, max: 7_200_000 });
+        }
         if (Object.keys(patch.control_plane.operator).length === 0) {
             delete patch.control_plane.operator;
         }
@@ -288,6 +295,9 @@ export function applyMuConfigPatch(base, patchInput) {
         if ("thinking" in operator) {
             next.control_plane.operator.thinking = operator.thinking ?? null;
         }
+        if ("timeout_ms" in operator && typeof operator.timeout_ms === "number" && Number.isFinite(operator.timeout_ms)) {
+            next.control_plane.operator.timeout_ms = normalizeInteger(operator.timeout_ms, next.control_plane.operator.timeout_ms, { min: 1_000, max: 7_200_000 });
+        }
     }
     const memoryIndex = patch.control_plane.memory_index;
     if (memoryIndex) {
@@ -373,6 +383,7 @@ export function muConfigPresence(config) {
                 provider: isPresent(config.control_plane.operator.provider),
                 model: isPresent(config.control_plane.operator.model),
                 thinking: isPresent(config.control_plane.operator.thinking),
+                timeout_ms: config.control_plane.operator.timeout_ms,
             },
             memory_index: {
                 enabled: config.control_plane.memory_index.enabled,

package/dist/control_plane.d.ts

@@ -4,21 +4,35 @@ import { type ControlPlaneConfig, type ControlPlaneGenerationContext, type Contr
 import { detectAdapters } from "./control_plane_adapter_registry.js";
 export type { ActiveAdapter, ControlPlaneConfig, ControlPlaneGenerationContext, ControlPlaneHandle, ControlPlaneSessionLifecycle, ControlPlaneSessionMutationAction, ControlPlaneSessionMutationResult, NotifyOperatorsOpts, NotifyOperatorsResult, TelegramGenerationReloadResult, TelegramGenerationRollbackTrigger, TelegramGenerationSwapHooks, WakeDeliveryEvent, WakeDeliveryObserver, WakeNotifyContext, WakeNotifyDecision, } from "./control_plane_contract.js";
 export { detectAdapters };
+type TelegramInlineKeyboardButton = {
+    text: string;
+    callback_data: string;
+};
+type TelegramInlineKeyboardMarkup = {
+    inline_keyboard: TelegramInlineKeyboardButton[][];
+};
 export type TelegramSendMessagePayload = {
     chat_id: string;
     text: string;
     parse_mode?: "Markdown";
     disable_web_page_preview?: boolean;
+    reply_markup?: TelegramInlineKeyboardMarkup;
+    reply_to_message_id?: number;
+    allow_sending_without_reply?: boolean;
 };
 export type TelegramSendPhotoPayload = {
     chat_id: string;
     photo: string;
     caption?: string;
+    reply_to_message_id?: number;
+    allow_sending_without_reply?: boolean;
 };
 export type TelegramSendDocumentPayload = {
     chat_id: string;
     document: string;
     caption?: string;
+    reply_to_message_id?: number;
+    allow_sending_without_reply?: boolean;
 };
 /**
  * Telegram supports a markdown dialect that uses single markers for emphasis.
@@ -26,12 +40,19 @@ export type TelegramSendDocumentPayload = {
  * while preserving fenced code blocks verbatim.
  */
 export declare function renderTelegramMarkdown(text: string): string;
+/**
+ * Slack mrkdwn does not support Markdown headings.
+ * Normalize common heading markers while preserving fenced blocks.
+ */
+export declare function renderSlackMarkdown(text: string): string;
 export declare function containsTelegramMathNotation(text: string): boolean;
 export declare function buildTelegramSendMessagePayload(opts: {
     chatId: string;
     text: string;
     richFormatting: boolean;
 }): TelegramSendMessagePayload;
+export declare function splitTelegramMessageText(text: string, maxLen?: number): string[];
+export declare function splitSlackMessageText(text: string, maxLen?: number): string[];
 export declare function deliverTelegramOutboxRecord(opts: {
     botToken: string;
     record: OutboxRecord;

package/dist/control_plane.js

@@ -53,6 +53,34 @@ export function renderTelegramMarkdown(text) {
     }
     return out.join("\n");
 }
+/**
+ * Slack mrkdwn does not support Markdown headings.
+ * Normalize common heading markers while preserving fenced blocks.
+ */
+export function renderSlackMarkdown(text) {
+    const normalized = text.replaceAll("\r\n", "\n");
+    const lines = normalized.split("\n");
+    const out = [];
+    let inFence = false;
+    for (const line of lines) {
+        const trimmed = line.trimStart();
+        if (trimmed.startsWith("```")) {
+            inFence = !inFence;
+            out.push(line);
+            continue;
+        }
+        if (inFence) {
+            out.push(line);
+            continue;
+        }
+        let next = line;
+        next = next.replace(/^#{1,6}\s+(.+)$/, "*$1*");
+        next = next.replace(/\*\*(.+?)\*\*/g, "*$1*");
+        next = next.replace(/__(.+?)__/g, "_$1_");
+        out.push(next);
+    }
+    return out.join("\n");
+}
 const TELEGRAM_MATH_PATTERNS = [
     /\$\$[\s\S]+?\$\$/m,
     /(^|[^\\])\$[^$\n]+\$/m,
@@ -79,6 +107,155 @@ export function buildTelegramSendMessagePayload(opts) {
         disable_web_page_preview: true,
     };
 }
+const TELEGRAM_MESSAGE_MAX_LEN = 4_096;
+function maybeParseTelegramMessageId(value) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return Math.trunc(value);
+    }
+    if (typeof value === "string" && /^-?\d+$/.test(value.trim())) {
+        const parsed = Number.parseInt(value.trim(), 10);
+        if (Number.isFinite(parsed)) {
+            return parsed;
+        }
+    }
+    return null;
+}
+export function splitTelegramMessageText(text, maxLen = TELEGRAM_MESSAGE_MAX_LEN) {
+    if (text.length <= maxLen) {
+        return [text];
+    }
+    const chunks = [];
+    let cursor = 0;
+    while (cursor < text.length) {
+        const end = Math.min(text.length, cursor + maxLen);
+        if (end === text.length) {
+            chunks.push(text.slice(cursor));
+            break;
+        }
+        const window = text.slice(cursor, end);
+        const splitAtNewline = window.lastIndexOf("\n");
+        const splitPoint = splitAtNewline >= Math.floor(maxLen * 0.5) ? cursor + splitAtNewline + 1 : end;
+        chunks.push(text.slice(cursor, splitPoint));
+        cursor = splitPoint;
+    }
+    return chunks;
+}
+const SLACK_MESSAGE_MAX_LEN = 3_500;
+export function splitSlackMessageText(text, maxLen = SLACK_MESSAGE_MAX_LEN) {
+    if (text.length <= maxLen) {
+        return [text];
+    }
+    const chunks = [];
+    let cursor = 0;
+    while (cursor < text.length) {
+        const end = Math.min(text.length, cursor + maxLen);
+        if (end === text.length) {
+            chunks.push(text.slice(cursor));
+            break;
+        }
+        const window = text.slice(cursor, end);
+        const splitAtNewline = window.lastIndexOf("\n");
+        const splitPoint = splitAtNewline >= Math.floor(maxLen * 0.5) ? cursor + splitAtNewline + 1 : end;
+        chunks.push(text.slice(cursor, splitPoint));
+        cursor = splitPoint;
+    }
+    return chunks;
+}
+function slackBlocksForOutboxRecord(record, body) {
+    const interactionMessage = record.envelope.metadata?.interaction_message;
+    if (!interactionMessage || typeof interactionMessage !== "object") {
+        return undefined;
+    }
+    const rawActions = interactionMessage.actions;
+    if (!Array.isArray(rawActions) || rawActions.length === 0) {
+        return undefined;
+    }
+    const buttons = [];
+    for (const action of rawActions) {
+        if (!action || typeof action !== "object") {
+            continue;
+        }
+        const candidate = action;
+        if (typeof candidate.label !== "string" || typeof candidate.command !== "string") {
+            continue;
+        }
+        const normalized = candidate.command.trim().replace(/^\/mu\s+/i, "");
+        const confirm = /^confirm\s+([^\s]+)$/i.exec(normalized);
+        if (confirm?.[1]) {
+            buttons.push({
+                type: "button",
+                text: { type: "plain_text", text: candidate.label },
+                value: `confirm:${confirm[1]}`,
+                action_id: `confirm_${confirm[1]}`,
+            });
+            continue;
+        }
+        const cancel = /^cancel\s+([^\s]+)$/i.exec(normalized);
+        if (cancel?.[1]) {
+            buttons.push({
+                type: "button",
+                text: { type: "plain_text", text: candidate.label },
+                value: `cancel:${cancel[1]}`,
+                action_id: `cancel_${cancel[1]}`,
+            });
+        }
+    }
+    if (buttons.length === 0) {
+        return undefined;
+    }
+    return [
+        { type: "section", text: { type: "mrkdwn", text: body } },
+        { type: "actions", elements: buttons },
+    ];
+}
+function slackThreadTsFromMetadata(metadata) {
+    const candidates = [metadata?.slack_thread_ts, metadata?.slack_message_ts, metadata?.thread_ts];
+    for (const value of candidates) {
+        if (typeof value === "string" && value.trim().length > 0) {
+            return value.trim();
+        }
+    }
+    return undefined;
+}
+function slackStatusMessageTsFromMetadata(metadata) {
+    const value = metadata?.slack_status_message_ts;
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+function telegramReplyMarkupForOutboxRecord(record) {
+    const interactionMessage = record.envelope.metadata?.interaction_message;
+    if (!interactionMessage || typeof interactionMessage !== "object") {
+        return undefined;
+    }
+    const rawActions = interactionMessage.actions;
+    if (!Array.isArray(rawActions) || rawActions.length === 0) {
+        return undefined;
+    }
+    const row = [];
+    for (const action of rawActions) {
+        if (!action || typeof action !== "object") {
+            continue;
+        }
+        const candidate = action;
+        if (typeof candidate.label !== "string" || typeof candidate.command !== "string") {
+            continue;
+        }
+        const normalized = candidate.command.trim().replace(/^\/mu\s+/i, "");
+        const confirm = /^confirm\s+([^\s]+)$/i.exec(normalized);
+        if (confirm?.[1]) {
+            row.push({ text: candidate.label, callback_data: `confirm:${confirm[1]}` });
+            continue;
+        }
+        const cancel = /^cancel\s+([^\s]+)$/i.exec(normalized);
+        if (cancel?.[1]) {
+            row.push({ text: candidate.label, callback_data: `cancel:${cancel[1]}` });
+        }
+    }
+    return row.length > 0 ? { inline_keyboard: [row] } : undefined;
+}
 async function postTelegramMessage(botToken, payload) {
     return await fetch(`https://api.telegram.org/bot${botToken}/sendMessage`, {
         method: "POST",
@@ -133,37 +310,76 @@ function parseRetryDelayMs(res) {
     }
     return parsed * 1000;
 }
+async function sendTelegramTextChunks(opts) {
+    const chunks = splitTelegramMessageText(opts.basePayload.text);
+    for (const [index, chunk] of chunks.entries()) {
+        const payload = {
+            ...opts.basePayload,
+            text: chunk,
+            ...(index === 0 ? {} : { reply_markup: undefined, reply_to_message_id: undefined, allow_sending_without_reply: undefined }),
+        };
+        let res = await postTelegramMessage(opts.botToken, payload);
+        if (!res.ok && res.status === 400 && payload.parse_mode && opts.fallbackToPlainOnMarkdownError) {
+            const plainPayload = buildTelegramSendMessagePayload({
+                chatId: payload.chat_id,
+                text: payload.text,
+                richFormatting: false,
+            });
+            res = await postTelegramMessage(opts.botToken, {
+                ...plainPayload,
+                ...(payload.reply_markup ? { reply_markup: payload.reply_markup } : {}),
+                ...(payload.reply_to_message_id != null
+                    ? {
+                        reply_to_message_id: payload.reply_to_message_id,
+                        allow_sending_without_reply: payload.allow_sending_without_reply,
+                    }
+                    : {}),
+            });
+        }
+        if (!res.ok) {
+            return { ok: false, response: res, body: await res.text().catch(() => "") };
+        }
+    }
+    return { ok: true };
+}
 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 replyMarkup = telegramReplyMarkupForOutboxRecord(record);
+    const replyToMessageId = maybeParseTelegramMessageId(record.envelope.metadata?.telegram_reply_to_message_id);
+    const fallbackMessagePayload = {
+        ...buildTelegramSendMessagePayload({
+            chatId: record.envelope.channel_conversation_id,
+            text: record.envelope.body,
+            richFormatting: true,
+        }),
+        ...(replyMarkup ? { reply_markup: replyMarkup } : {}),
+        ...(replyToMessageId != null
+            ? {
+                reply_to_message_id: replyToMessageId,
+                allow_sending_without_reply: 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) {
+        const sent = await sendTelegramTextChunks({
+            botToken,
+            basePayload: fallbackMessagePayload,
+            fallbackToPlainOnMarkdownError: true,
+        });
+        if (sent.ok) {
             return { kind: "delivered" };
         }
-        const responseBody = await res.text().catch(() => "");
-        if (res.status === 429 || res.status >= 500) {
+        if (sent.response.status === 429 || sent.response.status >= 500) {
             return {
                 kind: "retry",
-                error: `telegram sendMessage ${res.status}: ${responseBody}`,
-                retryDelayMs: parseRetryDelayMs(res),
+                error: `telegram sendMessage ${sent.response.status}: ${sent.body}`,
+                retryDelayMs: parseRetryDelayMs(sent.response),
             };
         }
         return {
             kind: "retry",
-            error: `telegram sendMessage ${res.status}: ${responseBody}`,
+            error: `telegram sendMessage ${sent.response.status}: ${sent.body}`,
         };
     }
     const mediaMethod = chooseTelegramMediaMethod(firstAttachment);
@@ -180,11 +396,23 @@ export async function deliverTelegramOutboxRecord(opts) {
                 chat_id: record.envelope.channel_conversation_id,
                 photo: firstAttachment.reference.file_id,
                 caption: mediaCaption,
+                ...(replyToMessageId != null
+                    ? {
+                        reply_to_message_id: replyToMessageId,
+                        allow_sending_without_reply: true,
+                    }
+                    : {}),
             }
             : {
                 chat_id: record.envelope.channel_conversation_id,
                 document: firstAttachment.reference.file_id,
                 caption: mediaCaption,
+                ...(replyToMessageId != null
+                    ? {
+                        reply_to_message_id: replyToMessageId,
+                        allow_sending_without_reply: true,
+                    }
+                    : {}),
             });
     }
     else {
@@ -206,6 +434,10 @@ export async function deliverTelegramOutboxRecord(opts) {
         if (mediaCaption.length > 0) {
             form.append("caption", mediaCaption);
         }
+        if (replyToMessageId != null) {
+            form.append("reply_to_message_id", String(replyToMessageId));
+            form.append("allow_sending_without_reply", "true");
+        }
         form.append(mediaField, new Blob([body], { type: contentType }), filename);
         mediaResponse = await postTelegramApiMultipart(botToken, mediaMethod, form);
     }
@@ -220,26 +452,38 @@ export async function deliverTelegramOutboxRecord(opts) {
             retryDelayMs: parseRetryDelayMs(mediaResponse),
         };
     }
-    const fallbackPlainPayload = buildTelegramSendMessagePayload({
-        chatId: record.envelope.channel_conversation_id,
-        text: record.envelope.body,
-        richFormatting: false,
+    const fallbackPlainPayload = {
+        ...buildTelegramSendMessagePayload({
+            chatId: record.envelope.channel_conversation_id,
+            text: record.envelope.body,
+            richFormatting: false,
+        }),
+        ...(replyMarkup ? { reply_markup: replyMarkup } : {}),
+        ...(replyToMessageId != null
+            ? {
+                reply_to_message_id: replyToMessageId,
+                allow_sending_without_reply: true,
+            }
+            : {}),
+    };
+    const fallbackSent = await sendTelegramTextChunks({
+        botToken,
+        basePayload: fallbackPlainPayload,
+        fallbackToPlainOnMarkdownError: false,
     });
-    const fallbackRes = await postTelegramMessage(botToken, fallbackPlainPayload);
-    if (fallbackRes.ok) {
+    if (fallbackSent.ok) {
         return { kind: "delivered" };
     }
-    const fallbackBody = await fallbackRes.text().catch(() => "");
-    if (fallbackRes.status === 429 || fallbackRes.status >= 500) {
+    if (fallbackSent.response.status === 429 || fallbackSent.response.status >= 500) {
         return {
             kind: "retry",
-            error: `telegram media fallback sendMessage ${fallbackRes.status}: ${fallbackBody}`,
-            retryDelayMs: parseRetryDelayMs(fallbackRes),
+            error: `telegram media fallback sendMessage ${fallbackSent.response.status}: ${fallbackSent.body}`,
+            retryDelayMs: parseRetryDelayMs(fallbackSent.response),
         };
     }
     return {
         kind: "retry",
-        error: `telegram media fallback sendMessage ${fallbackRes.status}: ${fallbackBody} (media_error=${mediaMethod} ${mediaResponse.status}: ${mediaBody})`,
+        error: `telegram media fallback sendMessage ${fallbackSent.response.status}: ${fallbackSent.body} (media_error=${mediaMethod} ${mediaResponse.status}: ${mediaBody})`,
     };
 }
 async function postSlackJson(opts) {
@@ -257,30 +501,75 @@ async function postSlackJson(opts) {
 export async function deliverSlackOutboxRecord(opts) {
     const { botToken, record } = opts;
     const attachments = record.envelope.attachments ?? [];
+    const renderedBody = renderSlackMarkdown(record.envelope.body);
+    const textChunks = splitSlackMessageText(renderedBody);
+    const blocks = slackBlocksForOutboxRecord(record, renderedBody);
+    const threadTs = slackThreadTsFromMetadata(record.envelope.metadata);
+    const statusMessageTs = slackStatusMessageTsFromMetadata(record.envelope.metadata);
     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" };
+        let chunkStartIndex = 0;
+        if (statusMessageTs && textChunks.length > 0) {
+            const updated = await postSlackJson({
+                botToken,
+                method: "chat.update",
+                payload: {
+                    channel: record.envelope.channel_conversation_id,
+                    ts: statusMessageTs,
+                    text: textChunks[0],
+                    unfurl_links: false,
+                    unfurl_media: false,
+                    ...(blocks ? { blocks } : {}),
+                },
+            });
+            if (updated.response.ok && updated.payload?.ok) {
+                chunkStartIndex = 1;
+            }
+            else {
+                const status = updated.response.status;
+                const err = updated.payload?.error ?? "unknown_error";
+                if (status === 429 || status >= 500) {
+                    return {
+                        kind: "retry",
+                        error: `slack chat.update ${status}: ${err}`,
+                        retryDelayMs: parseRetryDelayMs(updated.response),
+                    };
+                }
+                if (err !== "message_not_found" && err !== "cant_update_message") {
+                    return { kind: "retry", error: `slack chat.update ${status}: ${err}` };
+                }
+            }
         }
-        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),
-            };
+        for (const [index, chunk] of textChunks.entries()) {
+            if (index < chunkStartIndex) {
+                continue;
+            }
+            const delivered = await postSlackJson({
+                botToken,
+                method: "chat.postMessage",
+                payload: {
+                    channel: record.envelope.channel_conversation_id,
+                    text: chunk,
+                    unfurl_links: false,
+                    unfurl_media: false,
+                    ...(index === 0 && blocks ? { blocks } : {}),
+                    ...(threadTs ? { thread_ts: threadTs } : {}),
+                },
+            });
+            if (delivered.response.ok && delivered.payload?.ok) {
+                continue;
+            }
+            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}` };
         }
-        return { kind: "retry", error: `slack chat.postMessage ${status}: ${err}` };
+        return { kind: "delivered" };
     }
     let firstError = null;
     for (const [index, attachment] of attachments.entries()) {
@@ -311,7 +600,10 @@ export async function deliverSlackOutboxRecord(opts) {
         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("initial_comment", textChunks[0] ?? record.envelope.body);
+        }
+        if (threadTs) {
+            form.set("thread_ts", threadTs);
         }
         form.set("file", new Blob([bytes], { type: contentType }), filename);
         const uploaded = await fetch("https://slack.com/api/files.upload", {
@@ -337,33 +629,39 @@ export async function deliverSlackOutboxRecord(opts) {
             }
         }
     }
-    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) {
+    if (firstError || textChunks.length > 1) {
+        for (const [index, chunk] of textChunks.entries()) {
+            if (index === 0 && !firstError) {
+                continue;
+            }
+            const fallback = await postSlackJson({
+                botToken,
+                method: "chat.postMessage",
+                payload: {
+                    channel: record.envelope.channel_conversation_id,
+                    text: chunk,
+                    unfurl_links: false,
+                    unfurl_media: false,
+                    ...(threadTs ? { thread_ts: threadTs } : {}),
+                },
+            });
+            if (fallback.response.ok && fallback.payload?.ok) {
+                continue;
+            }
+            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}${firstError ? ` (upload_error=${firstError})` : ""}`,
+                    retryDelayMs: parseRetryDelayMs(fallback.response),
+                };
+            }
             return {
                 kind: "retry",
-                error: `slack chat.postMessage fallback ${status}: ${err} (upload_error=${firstError})`,
-                retryDelayMs: parseRetryDelayMs(fallback.response),
+                error: `slack chat.postMessage fallback ${status}: ${err}${firstError ? ` (upload_error=${firstError})` : ""}`,
             };
         }
-        return {
-            kind: "retry",
-            error: `slack chat.postMessage fallback ${status}: ${err} (upload_error=${firstError})`,
-        };
     }
     return { kind: "delivered" };
 }

package/dist/control_plane_bootstrap_helpers.js

@@ -11,6 +11,7 @@ export function buildMessagingOperatorRuntime(opts) {
             provider: opts.config.operator.provider ?? undefined,
             model: opts.config.operator.model ?? undefined,
             thinking: opts.config.operator.thinking ?? undefined,
+            timeoutMs: opts.config.operator.timeout_ms,
             extensionPaths: operatorExtensionPaths,
         });
     const conversationSessionStore = new JsonFileConversationSessionStore(join(getControlPlanePaths(opts.repoRoot).controlPlaneDir, "operator_conversations.json"));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@femtomc/mu-server",
-  "version": "26.2.95",
+  "version": "26.2.97",
   "description": "HTTP API server for mu control-plane transport/session plus run/activity scheduling coordination.",
   "keywords": [
     "mu",
@@ -30,8 +30,8 @@
     "start": "bun run dist/cli.js"
   },
   "dependencies": {
-    "@femtomc/mu-agent": "26.2.95",
-    "@femtomc/mu-control-plane": "26.2.95",
-    "@femtomc/mu-core": "26.2.95"
+    "@femtomc/mu-agent": "26.2.97",
+    "@femtomc/mu-control-plane": "26.2.97",
+    "@femtomc/mu-core": "26.2.97"
   }
 }