@llblab/pi-telegram 0.55.1 → 0.56.1

package/dist/lib/menu-queue.js

@@ -4,6 +4,7 @@
  * Owns queue-menu rendering, queue item callbacks, and queue-menu runtime adapters while core queue mechanics stay in queue
  */
 import { createTelegramMenuDelivery, } from "./menu-model.js";
+import * as Queue from "./queue.js";
 const QUEUE_ITEM_PROMPT_HTML_LIMIT = 3600;
 const QUEUE_ITEM_PROMPT_TRUNCATION_SUFFIX = "\n… [truncated]";
 const EMPTY_QUEUE_REFRESH_TITLES = [
@@ -29,15 +30,25 @@ function getTelegramQueueItemPromptText(item) {
         .join("\n")
         .trim() || item.statusSummary);
 }
-function toTelegramQueueMenuItems(items) {
+function toTelegramQueueMenuItems(items, pendingDispatch = false) {
+    const head = items[0];
     return items.map((item, index) => {
+        const dispatchProtected = pendingDispatch && (item === head ||
+            (head?.kind === "prompt" && head.steerPacketTail?.includes(item) === true));
+        const attemptFrozen = item.kind === "prompt" && item.steerAttempted === true && !dispatchProtected;
+        const editable = item.kind === "prompt" && item.guestQueryId === undefined && item.guestInlineMessageId === undefined && !dispatchProtected && !attemptFrozen;
         return {
             chatId: item.chatId,
             replyToMessageId: item.replyToMessageId,
             queueOrder: item.queueOrder,
             isGuest: item.kind === "prompt" && item.guestQueryId !== undefined,
             queuePosition: index + 1,
-            isPriority: item.queueLane === "priority",
+            queueLane: item.queueLane,
+            canSelectLane: editable && item.queueLane !== "control",
+            canSelectDisposition: editable && (item.queueLane !== "control" || item.sourceMessageIds.includes(item.replyToMessageId)),
+            dispatchProtected, attemptFrozen,
+            exceedsIdleCapacity: item.kind === "prompt" && item.queueLane === "steer" && !item.steerAttempted &&
+                !Queue.isTelegramSteerItemWithinIdleCapacity(item),
             priorityEmoji: item.kind === "prompt" ? item.priorityEmoji : undefined,
             reactionSuppressionEmoji: item.kind === "prompt" ? item.reactionSuppressionEmoji : undefined,
             hasAttachments: item.kind === "prompt" && item.queuedAttachments.length > 0,
@@ -59,18 +70,16 @@ function buildTelegramQueueMenuReplyMarkup(items, emptyRefreshIndex = 0) {
     if (items.length === 0)
         return { inline_keyboard: [backRow, refreshRow] };
     const rows = items.map((item) => {
-        const prefix = item.reactionSuppressionEmoji
-            ? `${item.reactionSuppressionEmoji} `
-            : item.isPriority
-                ? `${item.priorityEmoji ?? "⚡"} `
-                : item.hasAttachments
-                    ? "📎 "
-                    : "";
+        const badge = getTelegramQueueMenuLaneBadge(item);
+        const prefix = item.reactionSuppressionEmoji ? `${item.reactionSuppressionEmoji} ` :
+            badge ? `${badge} ` : item.hasAttachments ? "📎 " : "";
         const position = item.reactionSuppressionEmoji
             ? formatSkippedTelegramQueuePosition(item.queuePosition)
             : String(item.queuePosition);
         const ordinalSeparator = item.reactionSuppressionEmoji ? "\u200A" : "";
-        const label = `${position}${ordinalSeparator}. ${prefix}${item.statusSummary}`;
+        const state = item.attemptFrozen ? " · frozen" : item.dispatchProtected ? " · dispatch protected" :
+            item.exceedsIdleCapacity ? " · idle capacity" : "";
+        const label = `${position}${ordinalSeparator}. ${prefix}${item.statusSummary}${state}`;
         return [
             {
                 text: label,
@@ -114,18 +123,29 @@ function escapeTelegramQueueMenuHtmlPreview(text) {
     }
     return truncated ? escaped + suffix : escaped;
 }
+function getTelegramQueueMenuLaneBadge(item) {
+    if (item.queueLane === "control")
+        return "⚡";
+    if (item.queueLane === "steer")
+        return "🔥";
+    if (item.queueLane !== "priority")
+        return "";
+    const emoji = item.priorityEmoji?.replace(/\uFE0F/g, "");
+    return emoji === "❤" || emoji === "🕊" ? emoji : "👍";
+}
 function getTelegramQueueMenuItemText(item) {
-    const badge = item.reactionSuppressionEmoji
-        ? ` ${item.reactionSuppressionEmoji}`
-        : item.isPriority
-            ? ` ${item.priorityEmoji ?? "⚡"}`
-            : "";
+    const marker = item.reactionSuppressionEmoji ?? getTelegramQueueMenuLaneBadge(item);
+    const badge = marker ? ` ${marker}` : "";
     const position = item.reactionSuppressionEmoji
         ? `<s>${item.queuePosition}</s>.`
         : `<b>${item.queuePosition}.</b>`;
     const heading = `${position}${badge}`;
     const preview = `<pre>${escapeTelegramQueueMenuHtmlPreview(item.promptText)}</pre>`;
-    return `${heading}\n${preview}`;
+    const note = item.attemptFrozen ? "\n<b>⚠️ Attempt frozen.</b>\nSDK/model use is unconfirmed; not editable or automatically retried." :
+        item.dispatchProtected ? "\n<b>⏳ Dispatch protected.</b>\nWaiting for agent_start; SDK/model use is unconfirmed." :
+            item.exceedsIdleCapacity ? "\n<b>⚠️ Idle Steer capacity exceeded.</b>\nEdit the source or choose Priority/Normal; source groups are never split." :
+                item.queueLane === "control" ? "\nControl lane is producer-owned." : "";
+    return `${heading}\n${preview}${note}`;
 }
 function buildTelegramGuestQueueItemSubmenuReplyMarkup(queueOrder) {
     return {
@@ -140,32 +160,20 @@ function buildTelegramGuestQueueItemSubmenuReplyMarkup(queueOrder) {
         ],
     };
 }
-function buildTelegramQueueItemSubmenuReplyMarkup(chatId, replyToMessageId, isPriority, isSkipped) {
-    return {
-        inline_keyboard: [
-            [{ text: "⬆️ Back", callback_data: "queue:list" }],
-            [
-                {
-                    text: isPriority ? "🟡 Priority" : "⚫️ Priority",
-                    callback_data: `queue:prio-set:${chatId}:${replyToMessageId}:priority`,
-                },
-                {
-                    text: isPriority ? "⚫️ Normal" : "🔵 Normal",
-                    callback_data: `queue:prio-set:${chatId}:${replyToMessageId}:normal`,
-                },
-            ],
-            [
-                {
-                    text: isSkipped ? "⚫️ Keep" : "🟢 Keep",
-                    callback_data: `queue:skip-set:${chatId}:${replyToMessageId}:keep`,
-                },
-                {
-                    text: isSkipped ? "🔴 Skip" : "⚫️ Skip",
-                    callback_data: `queue:skip-set:${chatId}:${replyToMessageId}:skip`,
-                },
-            ],
-        ],
-    };
+function buildTelegramQueueItemSubmenuReplyMarkup(item) {
+    const rows = [[{ text: "⬆️ Back", callback_data: "queue:list" }]];
+    if (item.canSelectLane)
+        rows.push([
+            { text: item.queueLane === "default" ? "🔵 Normal" : "⚫️ Normal", callback_data: `queue:lane-set:${item.chatId}:${item.replyToMessageId}:normal` },
+            { text: item.queueLane === "priority" ? "🟣 Priority" : "⚫️ Priority", callback_data: `queue:lane-set:${item.chatId}:${item.replyToMessageId}:priority` },
+            { text: item.queueLane === "steer" ? "🟡 Steer" : "⚫️ Steer", callback_data: `queue:lane-set:${item.chatId}:${item.replyToMessageId}:steer` },
+        ]);
+    if (item.canSelectDisposition)
+        rows.push([
+            { text: item.reactionSuppressionEmoji ? "⚫️ Keep" : "🟢 Keep", callback_data: `queue:skip-set:${item.chatId}:${item.replyToMessageId}:keep` },
+            { text: item.reactionSuppressionEmoji ? "🔴 Skip" : "⚫️ Skip", callback_data: `queue:skip-set:${item.chatId}:${item.replyToMessageId}:skip` },
+        ]);
+    return { inline_keyboard: rows };
 }
 async function handleTelegramQueueMenuCallback(callbackQueryId, data, replyChatId, replyMessageId, ctx, deps) {
     if (!data.startsWith("queue:"))
@@ -190,7 +198,13 @@ async function handleTelegramQueueMenuCallback(callbackQueryId, data, replyChatI
     }
     const guestSkipMatch = data.match(/^queue:guest-skip:(\d+)$/);
     if (guestSkipMatch) {
-        const skipped = await deps.skipGuest(Number(guestSkipMatch[1]), ctx);
+        const queueOrder = Number(guestSkipMatch[1]);
+        const item = deps.findGuestItem(queueOrder);
+        if (item?.dispatchProtected || item?.attemptFrozen) {
+            await deps.answerCallbackQuery(callbackQueryId, "Queue item is protected");
+            return true;
+        }
+        const skipped = await deps.skipGuest(queueOrder, ctx);
         if (!skipped) {
             await refreshStaleTelegramQueueMenuItem(callbackQueryId, replyChatId, replyMessageId, deps);
             return true;
@@ -203,9 +217,9 @@ async function handleTelegramQueueMenuCallback(callbackQueryId, data, replyChatI
         await handleTelegramQueueMenuPick(callbackQueryId, replyChatId, replyMessageId, Number(pickMatch[1]), Number(pickMatch[2]), deps);
         return true;
     }
-    const prioSetMatch = data.match(/^queue:prio-set:(\d+):(\d+):(priority|normal)$/);
+    const prioSetMatch = data.match(/^queue:(?:lane-set|prio-set):(\d+):(\d+):(steer|priority|normal)$/);
     if (prioSetMatch) {
-        await handleTelegramQueueMenuPrioritySet(callbackQueryId, replyChatId, replyMessageId, Number(prioSetMatch[1]), Number(prioSetMatch[2]), prioSetMatch[3] === "priority", ctx, deps);
+        await handleTelegramQueueMenuLaneSet(callbackQueryId, replyChatId, replyMessageId, Number(prioSetMatch[1]), Number(prioSetMatch[2]), prioSetMatch[3] === "normal" ? "default" : prioSetMatch[3], ctx, deps);
         return true;
     }
     const prioMatch = data.match(/^queue:prio:(\d+):(\d+)$/);
@@ -240,7 +254,9 @@ async function handleTelegramGuestQueueMenuPick(callbackQueryId, replyChatId, re
     if (!item) {
         return refreshStaleTelegramQueueMenuItem(callbackQueryId, replyChatId, replyMessageId, deps);
     }
-    await deps.updateQueueMessage(replyChatId, replyMessageId, getTelegramQueueMenuItemText(item), buildTelegramGuestQueueItemSubmenuReplyMarkup(queueOrder));
+    await deps.updateQueueMessage(replyChatId, replyMessageId, getTelegramQueueMenuItemText(item), item.dispatchProtected || item.attemptFrozen
+        ? buildTelegramQueueItemSubmenuReplyMarkup(item)
+        : buildTelegramGuestQueueItemSubmenuReplyMarkup(queueOrder));
     await deps.answerCallbackQuery(callbackQueryId);
 }
 async function handleTelegramQueueMenuPick(callbackQueryId, replyChatId, replyMessageId, chatId, msgId, deps) {
@@ -248,7 +264,7 @@ async function handleTelegramQueueMenuPick(callbackQueryId, replyChatId, replyMe
     if (!item) {
         return refreshStaleTelegramQueueMenuItem(callbackQueryId, replyChatId, replyMessageId, deps);
     }
-    await deps.updateQueueMessage(replyChatId, replyMessageId, getTelegramQueueMenuItemText(item), buildTelegramQueueItemSubmenuReplyMarkup(chatId, msgId, item.isPriority, item.reactionSuppressionEmoji !== undefined));
+    await deps.updateQueueMessage(replyChatId, replyMessageId, getTelegramQueueMenuItemText(item), buildTelegramQueueItemSubmenuReplyMarkup(item));
     await deps.answerCallbackQuery(callbackQueryId);
 }
 async function handleTelegramQueueMenuPriority(callbackQueryId, replyChatId, replyMessageId, chatId, msgId, ctx, deps) {
@@ -256,37 +272,43 @@ async function handleTelegramQueueMenuPriority(callbackQueryId, replyChatId, rep
     if (!item) {
         return refreshStaleTelegramQueueMenuItem(callbackQueryId, replyChatId, replyMessageId, deps);
     }
-    await updateTelegramQueueMenuPriority(callbackQueryId, replyChatId, replyMessageId, chatId, msgId, !item.isPriority, ctx, deps);
+    await updateTelegramQueueMenuLane(callbackQueryId, replyChatId, replyMessageId, chatId, msgId, item.queueLane === "priority" ? "default" : "priority", ctx, deps);
 }
-async function handleTelegramQueueMenuPrioritySet(callbackQueryId, replyChatId, replyMessageId, chatId, msgId, enabled, ctx, deps) {
+async function handleTelegramQueueMenuLaneSet(callbackQueryId, replyChatId, replyMessageId, chatId, msgId, lane, ctx, deps) {
     const item = deps.findItem(chatId, msgId);
     if (!item) {
         return refreshStaleTelegramQueueMenuItem(callbackQueryId, replyChatId, replyMessageId, deps);
     }
-    await updateTelegramQueueMenuPriority(callbackQueryId, replyChatId, replyMessageId, chatId, msgId, enabled, ctx, deps);
+    await updateTelegramQueueMenuLane(callbackQueryId, replyChatId, replyMessageId, chatId, msgId, lane, ctx, deps);
 }
-async function updateTelegramQueueMenuPriority(callbackQueryId, replyChatId, replyMessageId, chatId, msgId, enabled, ctx, deps) {
-    deps.setPriority(chatId, msgId, enabled);
+async function updateTelegramQueueMenuLane(callbackQueryId, replyChatId, replyMessageId, chatId, msgId, lane, ctx, deps) {
+    if (!deps.setLane(chatId, msgId, lane)) {
+        await deps.answerCallbackQuery(callbackQueryId, "Queue item is protected");
+        return;
+    }
     deps.updateStatus(ctx);
     const updated = deps.findItem(chatId, msgId);
     if (!updated) {
         return refreshStaleTelegramQueueMenuItem(callbackQueryId, replyChatId, replyMessageId, deps);
     }
-    await deps.updateQueueMessage(replyChatId, replyMessageId, getTelegramQueueMenuItemText(updated), buildTelegramQueueItemSubmenuReplyMarkup(chatId, msgId, updated.isPriority, updated.reactionSuppressionEmoji !== undefined));
-    await deps.answerCallbackQuery(callbackQueryId, updated.isPriority ? "Prioritized" : "Normal priority");
+    await deps.updateQueueMessage(replyChatId, replyMessageId, getTelegramQueueMenuItemText(updated), buildTelegramQueueItemSubmenuReplyMarkup(updated));
+    await deps.answerCallbackQuery(callbackQueryId, updated.queueLane === "steer" ? "Steer selected" : updated.queueLane === "priority" ? "Prioritized" : "Normal priority");
 }
 async function handleTelegramQueueMenuSkipSet(callbackQueryId, replyChatId, replyMessageId, chatId, msgId, skipped, ctx, deps) {
     const item = deps.findItem(chatId, msgId);
     if (!item) {
         return refreshStaleTelegramQueueMenuItem(callbackQueryId, replyChatId, replyMessageId, deps);
     }
-    deps.setSkipped(chatId, msgId, skipped);
+    if (!deps.setSkipped(chatId, msgId, skipped)) {
+        await deps.answerCallbackQuery(callbackQueryId, "Queue item is protected");
+        return;
+    }
     deps.updateStatus(ctx);
     const updated = deps.findItem(chatId, msgId);
     if (!updated) {
         return refreshStaleTelegramQueueMenuItem(callbackQueryId, replyChatId, replyMessageId, deps);
     }
-    await deps.updateQueueMessage(replyChatId, replyMessageId, getTelegramQueueMenuItemText(updated), buildTelegramQueueItemSubmenuReplyMarkup(chatId, msgId, updated.isPriority, updated.reactionSuppressionEmoji !== undefined));
+    await deps.updateQueueMessage(replyChatId, replyMessageId, getTelegramQueueMenuItemText(updated), buildTelegramQueueItemSubmenuReplyMarkup(updated));
     await deps.answerCallbackQuery(callbackQueryId);
 }
 export function createTelegramQueueMenuRuntime(deps) {
@@ -297,6 +319,7 @@ export function createTelegramQueueMenuRuntime(deps) {
             const delivery = createTelegramMenuDelivery({ chatId, threadId }, options, deps);
             return createOpenQueueMenu({
                 getQueuedItems: deps.telegramQueueStore.getQueuedItems,
+                hasPendingDispatch: deps.hasPendingDispatch,
                 getModelMenuState: (chat, context) => deps.getModelMenuState(chat, context, threadId),
                 storeModelMenuState: delivery.storeModelMenuState,
                 sendInteractiveMessage: delivery.assertAuthority
@@ -305,6 +328,7 @@ export function createTelegramQueueMenuRuntime(deps) {
             })(chatId, replyToMessageId, ctx);
         },
         handleCallbackQuery: createQueueMenuCallbackHandler({
+            hasPendingDispatch: deps.hasPendingDispatch,
             telegramQueueStore: deps.telegramQueueStore,
             queueMutationRuntime: deps.queueMutationRuntime,
             editInteractiveMessage: editQueueMenuMessage,
@@ -319,7 +343,7 @@ export function createTelegramQueueMenuRuntime(deps) {
 function createOpenQueueMenu(deps) {
     return async (chatId, replyToMessageId, ctx) => {
         const state = await deps.getModelMenuState(chatId, ctx);
-        const menuItems = toTelegramQueueMenuItems(deps.getQueuedItems());
+        const menuItems = toTelegramQueueMenuItems(deps.getQueuedItems(), deps.hasPendingDispatch?.());
         const text = getTelegramQueueMenuListText(menuItems);
         const messageId = await deps.sendInteractiveMessage(chatId, replyToMessageId, text, buildTelegramQueueMenuReplyMarkup(menuItems));
         if (messageId === undefined)
@@ -342,7 +366,7 @@ function createQueueMenuCallbackHandler(deps) {
                 await deps.answerCallbackQuery(query.id, "Interactive message expired");
                 return true;
             }
-            const menuItems = toTelegramQueueMenuItems(deps.telegramQueueStore.getQueuedItems());
+            const menuItems = toTelegramQueueMenuItems(deps.telegramQueueStore.getQueuedItems(), deps.hasPendingDispatch?.());
             await deps.editInteractiveMessage(chatId, messageId, getTelegramQueueMenuListText(menuItems), buildTelegramQueueMenuReplyMarkup(menuItems));
             state.mode = "queue";
             await deps.answerCallbackQuery(query.id);
@@ -354,7 +378,7 @@ function createQueueMenuCallbackHandler(deps) {
             return deps.telegramQueueStore.getQueuedItems();
         };
         const toMenuItems = () => {
-            return toTelegramQueueMenuItems(getQueueSnapshot());
+            return toTelegramQueueMenuItems(getQueueSnapshot(), deps.hasPendingDispatch?.());
         };
         const findItem = (cId, rId) => {
             return findTelegramQueueItem(toMenuItems(), cId, rId);
@@ -367,6 +391,7 @@ function createQueueMenuCallbackHandler(deps) {
         const flagDeps = {
             getQueueSnapshot,
             queueMutationRuntime: deps.queueMutationRuntime,
+            hasPendingDispatch: deps.hasPendingDispatch,
         };
         return handleTelegramQueueMenuCallback(query.id, data, chatId, messageId, ctx, {
             getQueuedItems: toMenuItems,
@@ -379,17 +404,8 @@ function createQueueMenuCallbackHandler(deps) {
                     dismissGuestPlaceholder: deps.dismissGuestPlaceholder,
                 });
             },
-            togglePriority: (cId, rId) => applyQueuedTelegramPromptMenuFlags(cId, rId, ctx, flagDeps, (item) => ({
-                priority: item.queueLane !== "priority",
-                skipped: isQueuedTelegramPromptSkipped(item),
-            })),
-            setPriority: (cId, rId, enabled) => applyQueuedTelegramPromptMenuFlags(cId, rId, ctx, flagDeps, (item) => ({
-                priority: enabled,
-                skipped: isQueuedTelegramPromptSkipped(item),
-            })),
-            setSkipped: (cId, rId, skipped) => applyQueuedTelegramPromptMenuFlags(cId, rId, ctx, flagDeps, (item) => item.kind === "prompt"
-                ? { priority: item.queueLane === "priority", skipped }
-                : undefined),
+            setLane: (cId, rId, lane) => applyQueuedTelegramPromptMenuFlags(cId, rId, ctx, flagDeps, () => ({ lane })),
+            setSkipped: (cId, rId, skipped) => applyQueuedTelegramPromptMenuFlags(cId, rId, ctx, flagDeps, () => ({ skipped })),
             updateQueueMessage: deps.editInteractiveMessage,
             answerCallbackQuery: deps.answerCallbackQuery,
             updateStatus: deps.updateStatus,
@@ -413,39 +429,26 @@ async function skipQueuedTelegramGuestPrompt(queueOrder, ctx, deps) {
     }
     return true;
 }
-function getQueueMenuReactionDisposition(item, priority, skipped) {
-    if (priority && skipped) {
-        return {
-            kind: "priority-suppressed",
-            priorityEmoji: item.kind === "prompt" ? (item.priorityEmoji ?? "⚡") : "⚡",
-            suppressionEmoji: item.kind === "prompt" ? (item.reactionSuppressionEmoji ?? "👎") : "👎",
-        };
-    }
-    if (priority) {
-        return {
-            kind: "priority",
-            emoji: item.kind === "prompt" ? (item.priorityEmoji ?? "⚡") : "⚡",
-        };
-    }
-    if (skipped) {
-        return {
-            kind: "suppressed",
-            emoji: item.kind === "prompt" ? (item.reactionSuppressionEmoji ?? "👎") : "👎",
-        };
-    }
-    return { kind: "default" };
-}
-function isQueuedTelegramPromptSkipped(item) {
-    return item.kind === "prompt" && item.reactionSuppressionEmoji !== undefined;
-}
-/** Applies a menu Priority/Skip choice to one queued item through the reaction disposition path. */
+/** Each menu selection changes one dimension through the existing Queue owner. */
 function applyQueuedTelegramPromptMenuFlags(chatId, replyToMessageId, ctx, deps, chooseFlags) {
     const item = findTelegramQueueItem(deps.getQueueSnapshot(), chatId, replyToMessageId);
     const flags = item ? chooseFlags(item) : undefined;
-    if (!item || !flags)
+    if (!item || item.kind !== "prompt" || !flags)
         return false;
-    deps.queueMutationRuntime.applyReactionByMessageId(replyToMessageId, getQueueMenuReactionDisposition(item, flags.priority, flags.skipped), ctx);
-    return true;
+    const view = findTelegramQueueItem(toTelegramQueueMenuItems(deps.getQueueSnapshot(), deps.hasPendingDispatch?.()), chatId, replyToMessageId);
+    if (!view || (flags.lane !== undefined && !view.canSelectLane) || (flags.skipped !== undefined && !view.canSelectDisposition))
+        return false;
+    const disposition = { kind: "reaction-transition" };
+    if (flags.lane !== undefined) {
+        disposition.promptLane = flags.lane;
+        disposition.priorityEmoji = flags.lane === "steer" ? "🔥" : flags.lane === "priority" ?
+            getTelegramQueueMenuLaneBadge({ queueLane: "priority", priorityEmoji: item.queueLane === "priority" ? item.priorityEmoji : undefined }) : null;
+    }
+    if (flags.skipped !== undefined)
+        disposition.suppressionEmoji = flags.skipped ? (item.reactionSuppressionEmoji ?? "👎") : null;
+    return deps.queueMutationRuntime.applyReactionByMessageId(replyToMessageId, disposition, ctx) ||
+        ((flags.lane === undefined || flags.lane === item.queueLane) &&
+            (flags.skipped === undefined || flags.skipped === (item.reactionSuppressionEmoji !== undefined)));
 }
 function createQueueMenuSendMessageAdapter(sendInteractiveMessage) {
     return (chatId, _replyToMessageId, text, replyMarkup) => {

package/dist/lib/pi.d.ts

@@ -4,8 +4,8 @@
  * Owns direct pi SDK imports and exposes narrow bridge-facing helpers/types for the extension composition layer
  */
 import type { AssistantMessageEvent } from "@earendil-works/pi-ai";
-import { type AgentEndEvent, type AgentSettledEvent, type AgentStartEvent, type BeforeAgentStartEvent, type ExtensionAPI, type ExtensionCommandContext, type ExtensionContext, type InputEvent, type MessageEndEvent, type SessionBeforeCompactEvent, type SessionCompactEvent, type SessionShutdownEvent, type SessionStartEvent, type SlashCommandInfo, type UIPromptEndEvent, type UIPromptStartEvent } from "@earendil-works/pi-coding-agent";
-export type { AgentEndEvent, AgentSettledEvent, AgentStartEvent, AssistantMessageEvent, BeforeAgentStartEvent, ExtensionAPI, ExtensionCommandContext, ExtensionContext, InputEvent, MessageEndEvent, SessionBeforeCompactEvent, SessionCompactEvent, SessionShutdownEvent, SessionStartEvent, SlashCommandInfo, UIPromptEndEvent, UIPromptStartEvent, };
+import { type AgentEndEvent, type AgentSettledEvent, type AgentStartEvent, type BeforeAgentStartEvent, type ExtensionAPI, type ExtensionCommandContext, type ExtensionContext, type InputEvent, type MessageEndEvent, type SessionBeforeCompactEvent, type SessionCompactEvent, type SessionShutdownEvent, type SessionStartEvent, type SlashCommandInfo, type TurnEndEvent, type TurnEndEventResult, type UIPromptEndEvent, type UIPromptStartEvent } from "@earendil-works/pi-coding-agent";
+export type { AgentEndEvent, AgentSettledEvent, AgentStartEvent, AssistantMessageEvent, BeforeAgentStartEvent, ExtensionAPI, ExtensionCommandContext, ExtensionContext, InputEvent, MessageEndEvent, SessionBeforeCompactEvent, SessionCompactEvent, SessionShutdownEvent, SessionStartEvent, SlashCommandInfo, TurnEndEvent, TurnEndEventResult, UIPromptEndEvent, UIPromptStartEvent, };
 export interface SessionCompactFailedEvent {
     type: "session_compact_failed";
     reason: "manual" | "threshold" | "overflow";
@@ -72,5 +72,6 @@ export declare function getExtensionContextCwd(ctx: ExtensionContext): string;
 export declare function getExtensionContextSessionId(ctx: ExtensionContext): string;
 export declare function getExtensionContextSessionId(ctx: ExtensionContext | undefined): string | undefined;
 export declare function isExtensionContextIdle(ctx: ExtensionContext): boolean;
+export declare function isExtensionContextAbortRequested(ctx: ExtensionContext): boolean;
 export declare function hasExtensionContextPendingMessages(ctx: ExtensionContext): boolean;
 export declare function compactExtensionContext(ctx: ExtensionContext, callbacks: Parameters<ExtensionContext["compact"]>[0]): ReturnType<ExtensionContext["compact"]>;

package/dist/lib/pi.js

@@ -122,6 +122,9 @@ export function getExtensionContextSessionId(ctx) {
 export function isExtensionContextIdle(ctx) {
     return ctx.isIdle();
 }
+export function isExtensionContextAbortRequested(ctx) {
+    return ctx.signal?.aborted === true;
+}
 export function hasExtensionContextPendingMessages(ctx) {
     return ctx.hasPendingMessages();
 }

package/dist/lib/polling.d.ts

@@ -221,7 +221,9 @@ export interface TelegramThreadAwarePollingPorts<TContext, TOwner> {
         forceFreshLeaderThread?: boolean;
     }) => Promise<void>;
     stopPolling: () => Promise<void>;
-    registerFollowerWithOwner: (ctx: TContext, owner: TOwner) => Promise<boolean | undefined>;
+    registerFollowerWithOwner: (ctx: TContext, owner: TOwner, options?: {
+        recoverConnection?: boolean;
+    }) => Promise<boolean | undefined>;
     restoreFollowerWithOwner: (ctx: TContext, owner: TOwner) => Promise<boolean | undefined>;
     stopFollowerRegistration: () => void;
 }
@@ -233,7 +235,9 @@ export interface TelegramThreadAwarePollingControls<TContext, TOwner> {
     stopBusLeaderPolling: () => Promise<void>;
     startLeaderHealth: () => void;
     stopLeaderHealth: () => void;
-    registerFollowerWithLeader: (ctx: TContext, owner: TOwner) => Promise<boolean | undefined>;
+    registerFollowerWithLeader: (ctx: TContext, owner: TOwner, options?: {
+        recoverConnection?: boolean;
+    }) => Promise<boolean | undefined>;
     restoreFollowerWithLeader?: (ctx: TContext, owner: TOwner) => Promise<boolean | undefined>;
     hasRememberedWorkspaceBinding?: (ctx: TContext) => boolean;
     stopFollowerRegistration: () => void;

package/dist/lib/polling.js

@@ -752,10 +752,10 @@ export function createTelegramThreadAwarePollingPorts(deps) {
         }
         return deps.topicTargetStore.getBotState().threadMode === "enabled";
     };
-    const registerFollowerWithOwner = async (ctx, owner) => {
+    const registerFollowerWithOwner = async (ctx, owner, options) => {
         if (!(await refreshFollowerState()))
             return undefined;
-        return deps.registerFollowerWithLeader(ctx, owner);
+        return deps.registerFollowerWithLeader(ctx, owner, options);
     };
     const restoreFollowerWithOwner = async (ctx, owner) => {
         if (!(await refreshFollowerState())) {
@@ -844,7 +844,9 @@ export function createTelegramThreadCapabilityMonitor(deps) {
                 consecutiveDisabledProbes = 0;
             const botState = deps.topicTargetStore.getBotState();
             const current = botState.threadMode;
-            if (threadModeEnabled && current === "enabled")
+            // Persisted capability is not proof that this owner started its local bus.
+            if (threadModeEnabled && current === "enabled" &&
+                (deps.getPollingStartedWithTelegramBus() || !deps.ownsLock(ctx)))
                 return;
             if (!threadModeEnabled && current === "disabled") {
                 if (!deps.ownsLock(ctx) ||

package/dist/lib/queue.d.ts

@@ -1,8 +1,9 @@
 /**
  * Telegram queue core contracts and pure planning helpers
  * Zones: telegram queue, pi agent lifecycle, scheduling
- * Owns queue item contracts, lane admission, pure queue mutations, and dispatch planning
+ * Owns queue item contracts, lane admission, mutations, dispatch planning, and protected Steer publication attempts
  */
+import { type TurnEndEvent, type TurnEndEventResult } from "./pi.ts";
 export interface QueuedAttachment {
     path: string;
     fileName: string;
@@ -18,7 +19,7 @@ export interface TelegramPromptImageContent {
 }
 export type TelegramPromptContent = TelegramPromptTextContent | TelegramPromptImageContent;
 export type TelegramQueueItemKind = "prompt" | "control";
-export type TelegramQueueLane = "control" | "priority" | "default";
+export type TelegramQueueLane = "control" | "steer" | "priority" | "default";
 export type TelegramQueueReactionDisposition = {
     kind: "default";
 } | {
@@ -33,6 +34,7 @@ export type TelegramQueueReactionDisposition = {
     suppressionEmoji: string;
 } | {
     kind: "reaction-transition";
+    promptLane?: Exclude<TelegramQueueLane, "control">;
     priorityEmoji?: string | null;
     suppressionEmoji?: string | null;
 };
@@ -42,7 +44,7 @@ export interface TelegramQueueAdmissionReceipt {
     sourceUpdateIds: readonly number[];
     journalBindingKey?: string;
 }
-export type TelegramQueueAdmissionMode = "control-queue" | "priority-queue" | "default-queue";
+export type TelegramQueueAdmissionMode = "control-queue" | "steer-queue" | "priority-queue" | "default-queue";
 export interface TelegramQueueLaneContract {
     lane: TelegramQueueLane;
     admissionMode: TelegramQueueAdmissionMode;
@@ -84,6 +86,11 @@ export interface PendingTelegramTurn extends TelegramQueueItemBase {
     historyText: string;
     priorityEmoji?: string;
     reactionSuppressionEmoji?: string;
+    /** Frozen before receipt mutation; failed/partial attempts must never become executable again. */
+    steerAttempted?: true;
+    /** Original tail objects of an issued idle packet; metadata only, not another waiting queue. */
+    steerPacketTail?: readonly PendingTelegramTurn[];
+    steerPacketSourceOrders?: readonly number[];
     /** Emit the explicit aborted-turn notice when /next settles this active turn. */
     announceNextAbortOnEnd?: boolean;
     /** Turn should preferably be delivered as voice (mirror mode + user sent voice) */
@@ -220,8 +227,11 @@ export declare function appendTelegramQueueItem<TContext = unknown, TItem extend
 export declare function createTelegramQueueHandoff<TContext>(input: {
     handoffToken: string;
     item: TelegramQueueItem<TContext>;
+    steerSupported?: boolean;
 }): TelegramQueueHandoff;
-export declare function createTelegramQueueHandoffPayload<TContext>(item: TelegramQueueItem<TContext>): TelegramQueueHandoffPayload;
+export declare function createTelegramQueueHandoffPayload<TContext>(item: TelegramQueueItem<TContext>, options?: {
+    steerSupported?: boolean;
+}): TelegramQueueHandoffPayload;
 export declare function restoreTelegramQueueHandoffPayload<TContext>(payload: TelegramQueueHandoffPayload, createControlExecution: (payload: TelegramControlQueueHandoffPayload) => PendingTelegramControlItem<TContext>["execute"]): TelegramQueueItem<TContext>;
 export declare function removeTelegramQueueItemByReceipt<TContext>(input: {
     receipt: TelegramQueueAdmissionReceipt;
@@ -258,7 +268,6 @@ export declare function consumeDispatchedTelegramPrompt<TContext = unknown>(item
     activeTurn?: PendingTelegramTurn;
     remainingItems: TelegramQueueItem<TContext>[];
 };
-export declare function formatQueuedTelegramItemsStatus<TContext = unknown>(items: TelegramQueueItem<TContext>[]): string;
 export declare function truncateTelegramQueueSummary(text: string, maxWords?: number, maxLength?: number): string;
 export declare function canDispatchTelegramTurnState(state: TelegramDispatchGuardState): boolean;
 export interface TelegramDispatchReadinessDeps<TContext> {
@@ -296,6 +305,11 @@ export declare function createTelegramControlItemBuilder<TContext = unknown>(dep
 export type TelegramQueueDispatchAction<TContext = unknown> = {
     kind: "none";
     remainingItems: TelegramQueueItem<TContext>[];
+} | {
+    kind: "steer";
+    item: PendingTelegramTurn;
+    packet: readonly PendingTelegramTurn[];
+    remainingItems: TelegramQueueItem<TContext>[];
 } | {
     kind: "control";
     item: PendingTelegramControlItem<TContext>;
@@ -305,6 +319,38 @@ export type TelegramQueueDispatchAction<TContext = unknown> = {
     item: PendingTelegramTurn;
     remainingItems: TelegramQueueItem<TContext>[];
 };
+export type TelegramSteerPacketPlan = {
+    kind: "none";
+} | {
+    kind: "skip";
+    item: PendingTelegramTurn;
+} | {
+    kind: "packet";
+    items: readonly PendingTelegramTurn[];
+};
+/** Plan a fixed ready prefix; publication/settlement remain with the Queue effect shell. */
+export declare function planTelegramSteerPacket<TContext>(items: readonly TelegramQueueItem<TContext>[], options: {
+    blocked: boolean;
+    isItemReady: (item: TelegramQueueItem<TContext>) => boolean;
+    canAppend?: (packet: readonly PendingTelegramTurn[], item: PendingTelegramTurn) => boolean;
+}): TelegramSteerPacketPlan;
+export declare function isTelegramSteerItemWithinIdleCapacity(item: PendingTelegramTurn): boolean;
+export interface TelegramSteerBoundaryRuntimeDeps<TContext> extends TelegramQueueStore<TContext> {
+    isContextCurrent: (ctx: TContext) => boolean;
+    isBlocked: (ctx: TContext) => boolean;
+    getGeneration: () => number;
+    isItemReady: (item: TelegramQueueItem<TContext>, ctx: TContext) => boolean;
+    isItemCurrent: (item: PendingTelegramTurn, ctx: TContext) => boolean;
+    getActiveTurn: () => PendingTelegramTurn | undefined;
+    commitPacket: (items: readonly PendingTelegramTurn[], ctx: TContext) => boolean;
+    discardItem: (item: PendingTelegramTurn, ctx: TContext) => boolean;
+    updateStatus: (ctx: TContext) => void;
+    recordRuntimeEvent?: TelegramRuntimeEventRecorderPort["recordRuntimeEvent"];
+}
+/** One publication attempt; journal ACK is source disposition, never SDK/model-use confirmation. */
+export declare function createTelegramSteerBoundaryRuntime<TContext>(deps: TelegramSteerBoundaryRuntimeDeps<TContext>): {
+    onTurnEnd(event: Pick<TurnEndEvent, "turnIndex" | "outcome">, ctx: TContext): TurnEndEventResult | undefined;
+};
 export declare function planNextTelegramQueueAction<TContext = unknown>(items: TelegramQueueItem<TContext>[], canDispatch: boolean): TelegramQueueDispatchAction<TContext>;
 export declare function shouldDispatchAfterTelegramAgentEnd(options: {
     hasTurn: boolean;
@@ -752,6 +798,12 @@ export interface TelegramQueueDispatchControllerDeps<TContext = unknown> extends
     sendUserMessage: TelegramDispatchRuntimeDeps<TContext>["sendUserMessage"];
     onPromptDispatchFailure: (ctx: TContext, message: string) => void;
     reconcileNextDispatchAnnouncementReplyOwnership?: (item: PendingTelegramTurn) => void;
+    steerDispatch?: {
+        commitPacket: (items: readonly PendingTelegramTurn[], ctx: TContext) => boolean;
+        isContextCurrent?: (ctx: TContext) => boolean;
+        /** Rechecks idle/native/abort guards without rejecting this packet's own pending flag. */
+        canSubmit?: (ctx: TContext) => boolean;
+    };
     isQueueItemTransportActive?: (item: TelegramQueueItem<TContext>) => boolean;
     hasPendingInboundQueueMutationForItem?: (item: TelegramQueueItem<TContext>) => boolean;
     isQueueItemAdmissionReady?: (item: TelegramQueueItem<TContext>) => boolean;